BOSS 7.0.7
BESIII Offline Software System
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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 Tue Jul 13 21:09:07 2021
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 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_etsT1", &m_etsT1);
5975 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_etsT2", &m_etsT2);
5976 TObject::ShowMembers(R__insp);
5977}
5978
5979namespace ROOT {
5980 // Wrappers around operator new
5981 static void *new_TEvtHeader(void *p) {
5982 return p ? new(p) ::TEvtHeader : new ::TEvtHeader;
5983 }
5984 static void *newArray_TEvtHeader(Long_t nElements, void *p) {
5985 return p ? new(p) ::TEvtHeader[nElements] : new ::TEvtHeader[nElements];
5986 }
5987 // Wrapper around operator delete
5988 static void delete_TEvtHeader(void *p) {
5989 delete ((::TEvtHeader*)p);
5990 }
5991 static void deleteArray_TEvtHeader(void *p) {
5992 delete [] ((::TEvtHeader*)p);
5993 }
5994 static void destruct_TEvtHeader(void *p) {
5995 typedef ::TEvtHeader current_t;
5996 ((current_t*)p)->~current_t();
5997 }
5998} // end of namespace ROOT for class ::TEvtHeader
5999
6000//______________________________________________________________________________
6001void TEvtNavigator::Streamer(TBuffer &R__b)
6002{
6003 // Stream an object of class TEvtNavigator.
6004
6005 if (R__b.IsReading()) {
6006 R__b.ReadClassBuffer(TEvtNavigator::Class(),this);
6007 } else {
6008 R__b.WriteClassBuffer(TEvtNavigator::Class(),this);
6009 }
6010}
6011
6012//______________________________________________________________________________
6013void TEvtNavigator::ShowMembers(TMemberInspector &R__insp)
6014{
6015 // Inspect the data members of an object of class TEvtNavigator.
6016 TClass *R__cl = ::TEvtNavigator::IsA();
6017 if (R__cl || R__insp.IsA()) { }
6018 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mcMdcMcHits", (void*)&m_mcMdcMcHits);
6019 R__insp.InspectMember("multimap<int,int>", (void*)&m_mcMdcMcHits, "m_mcMdcMcHits.", false);
6020 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mcMdcTracks", (void*)&m_mcMdcTracks);
6021 R__insp.InspectMember("multimap<int,int>", (void*)&m_mcMdcTracks, "m_mcMdcTracks.", false);
6022 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mcEmcMcHits", (void*)&m_mcEmcMcHits);
6023 R__insp.InspectMember("multimap<int,int>", (void*)&m_mcEmcMcHits, "m_mcEmcMcHits.", false);
6024 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mcEmcRecShowers", (void*)&m_mcEmcRecShowers);
6025 R__insp.InspectMember("multimap<int,int>", (void*)&m_mcEmcRecShowers, "m_mcEmcRecShowers.", false);
6026 TObject::ShowMembers(R__insp);
6027}
6028
6029namespace ROOT {
6030 // Wrappers around operator new
6031 static void *new_TEvtNavigator(void *p) {
6032 return p ? new(p) ::TEvtNavigator : new ::TEvtNavigator;
6033 }
6034 static void *newArray_TEvtNavigator(Long_t nElements, void *p) {
6035 return p ? new(p) ::TEvtNavigator[nElements] : new ::TEvtNavigator[nElements];
6036 }
6037 // Wrapper around operator delete
6038 static void delete_TEvtNavigator(void *p) {
6039 delete ((::TEvtNavigator*)p);
6040 }
6041 static void deleteArray_TEvtNavigator(void *p) {
6042 delete [] ((::TEvtNavigator*)p);
6043 }
6044 static void destruct_TEvtNavigator(void *p) {
6045 typedef ::TEvtNavigator current_t;
6046 ((current_t*)p)->~current_t();
6047 }
6048} // end of namespace ROOT for class ::TEvtNavigator
6049
6050//______________________________________________________________________________
6051void TRecExtTrack::Streamer(TBuffer &R__b)
6052{
6053 // Stream an object of class TRecExtTrack.
6054
6055 if (R__b.IsReading()) {
6056 R__b.ReadClassBuffer(TRecExtTrack::Class(),this);
6057 } else {
6058 R__b.WriteClassBuffer(TRecExtTrack::Class(),this);
6059 }
6060}
6061
6062//______________________________________________________________________________
6063void TRecExtTrack::ShowMembers(TMemberInspector &R__insp)
6064{
6065 // Inspect the data members of an object of class TRecExtTrack.
6066 TClass *R__cl = ::TRecExtTrack::IsA();
6067 if (R__cl || R__insp.IsA()) { }
6068 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
6069 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionX[5]", myTof1PositionX);
6070 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionY[5]", myTof1PositionY);
6071 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionZ[5]", myTof1PositionZ);
6072 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumX[5]", myTof1MomentumX);
6073 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumY[5]", myTof1MomentumY);
6074 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumZ[5]", myTof1MomentumZ);
6075 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1VolumeName[5]", myTof1VolumeName);
6076 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1VolumeNumber[5]", myTof1VolumeNumber);
6077 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1[5]", myTof1);
6078 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1Path[5]", myTof1Path);
6079 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongZ[5]", myTof1PosSigmaAlongZ);
6080 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongT[5]", myTof1PosSigmaAlongT);
6081 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongX[5]", myTof1PosSigmaAlongX);
6082 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongY[5]", myTof1PosSigmaAlongY);
6083 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1ErrorMatrix[5][6][6]", myTof1ErrorMatrix);
6084 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionX[5]", myTof2PositionX);
6085 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionY[5]", myTof2PositionY);
6086 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionZ[5]", myTof2PositionZ);
6087 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumX[5]", myTof2MomentumX);
6088 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumY[5]", myTof2MomentumY);
6089 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumZ[5]", myTof2MomentumZ);
6090 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2VolumeName[5]", myTof2VolumeName);
6091 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2VolumeNumber[5]", myTof2VolumeNumber);
6092 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2[5]", myTof2);
6093 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2Path[5]", myTof2Path);
6094 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongZ[5]", myTof2PosSigmaAlongZ);
6095 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongT[5]", myTof2PosSigmaAlongT);
6096 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongX[5]", myTof2PosSigmaAlongX);
6097 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongY[5]", myTof2PosSigmaAlongY);
6098 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2ErrorMatrix[5][6][6]", myTof2ErrorMatrix);
6099 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionX[5]", myEmcPositionX);
6100 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionY[5]", myEmcPositionY);
6101 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionZ[5]", myEmcPositionZ);
6102 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumX[5]", myEmcMomentumX);
6103 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumY[5]", myEmcMomentumY);
6104 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumZ[5]", myEmcMomentumZ);
6105 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcVolumeName[5]", myEmcVolumeName);
6106 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcVolumeNumber[5]", myEmcVolumeNumber);
6107 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPosSigmaAlongTheta[5]", myEmcPosSigmaAlongTheta);
6108 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPosSigmaAlongPhi[5]", myEmcPosSigmaAlongPhi);
6109 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcErrorMatrix[5][6][6]", myEmcErrorMatrix);
6110 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPath[5]", myEmcPath);
6111 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionX[5]", myMucPositionX);
6112 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionY[5]", myMucPositionY);
6113 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionZ[5]", myMucPositionZ);
6114 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumX[5]", myMucMomentumX);
6115 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumY[5]", myMucMomentumY);
6116 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumZ[5]", myMucMomentumZ);
6117 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucVolumeName[5]", myMucVolumeName);
6118 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucVolumeNumber[5]", myMucVolumeNumber);
6119 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongZ[5]", myMucPosSigmaAlongZ);
6120 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongT[5]", myMucPosSigmaAlongT);
6121 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongX[5]", myMucPosSigmaAlongX);
6122 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongY[5]", myMucPosSigmaAlongY);
6123 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucErrorMatrix[5][6][6]", myMucErrorMatrix);
6124 R__insp.Inspect(R__cl, R__insp.GetParent(), "mySize[5]", mySize);
6125 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPositionX[5]", myPositionX);
6126 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPositionY[5]", myPositionY);
6127 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPositionZ[5]", myPositionZ);
6128 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMomentumX[5]", myMomentumX);
6129 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMomentumY[5]", myMomentumY);
6130 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMomentumZ[5]", myMomentumZ);
6131 R__insp.Inspect(R__cl, R__insp.GetParent(), "myVolumeName[5]", myVolumeName);
6132 R__insp.Inspect(R__cl, R__insp.GetParent(), "myVolumeNumber[5]", myVolumeNumber);
6133 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPosSigmaAlongZ[5]", myPosSigmaAlongZ);
6134 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPosSigmaAlongT[5]", myPosSigmaAlongT);
6135 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPosSigmaAlongX[5]", myPosSigmaAlongX);
6136 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPosSigmaAlongY[5]", myPosSigmaAlongY);
6137 R__insp.Inspect(R__cl, R__insp.GetParent(), "myErrorMatrix[5]", myErrorMatrix);
6138 TObject::ShowMembers(R__insp);
6139}
6140
6141namespace ROOT {
6142 // Wrappers around operator new
6143 static void *new_TRecExtTrack(void *p) {
6144 return p ? new(p) ::TRecExtTrack : new ::TRecExtTrack;
6145 }
6146 static void *newArray_TRecExtTrack(Long_t nElements, void *p) {
6147 return p ? new(p) ::TRecExtTrack[nElements] : new ::TRecExtTrack[nElements];
6148 }
6149 // Wrapper around operator delete
6150 static void delete_TRecExtTrack(void *p) {
6151 delete ((::TRecExtTrack*)p);
6152 }
6153 static void deleteArray_TRecExtTrack(void *p) {
6154 delete [] ((::TRecExtTrack*)p);
6155 }
6156 static void destruct_TRecExtTrack(void *p) {
6157 typedef ::TRecExtTrack current_t;
6158 ((current_t*)p)->~current_t();
6159 }
6160} // end of namespace ROOT for class ::TRecExtTrack
6161
6162//______________________________________________________________________________
6163void TRecZddChannel::Streamer(TBuffer &R__b)
6164{
6165 // Stream an object of class TRecZddChannel.
6166
6167 if (R__b.IsReading()) {
6168 R__b.ReadClassBuffer(TRecZddChannel::Class(),this);
6169 } else {
6170 R__b.WriteClassBuffer(TRecZddChannel::Class(),this);
6171 }
6172}
6173
6174//______________________________________________________________________________
6175void TRecZddChannel::ShowMembers(TMemberInspector &R__insp)
6176{
6177 // Inspect the data members of an object of class TRecZddChannel.
6178 TClass *R__cl = ::TRecZddChannel::IsA();
6179 if (R__cl || R__insp.IsA()) { }
6180 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chId", &m_chId);
6181 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_scanCode", &m_scanCode);
6182 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_baseLine", &m_baseLine);
6183 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_phase", &m_phase);
6184 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_frags", (void*)&m_frags);
6185 R__insp.InspectMember("vector<std::pair<Int_t,Float_t> >", (void*)&m_frags, "m_frags.", false);
6186 TObject::ShowMembers(R__insp);
6187}
6188
6189namespace ROOT {
6190 // Wrappers around operator new
6191 static void *new_TRecZddChannel(void *p) {
6192 return p ? new(p) ::TRecZddChannel : new ::TRecZddChannel;
6193 }
6194 static void *newArray_TRecZddChannel(Long_t nElements, void *p) {
6195 return p ? new(p) ::TRecZddChannel[nElements] : new ::TRecZddChannel[nElements];
6196 }
6197 // Wrapper around operator delete
6198 static void delete_TRecZddChannel(void *p) {
6199 delete ((::TRecZddChannel*)p);
6200 }
6201 static void deleteArray_TRecZddChannel(void *p) {
6202 delete [] ((::TRecZddChannel*)p);
6203 }
6204 static void destruct_TRecZddChannel(void *p) {
6205 typedef ::TRecZddChannel current_t;
6206 ((current_t*)p)->~current_t();
6207 }
6208} // end of namespace ROOT for class ::TRecZddChannel
6209
6210//______________________________________________________________________________
6211void TTrigEvent::Streamer(TBuffer &R__b)
6212{
6213 // Stream an object of class TTrigEvent.
6214
6215 if (R__b.IsReading()) {
6216 R__b.ReadClassBuffer(TTrigEvent::Class(),this);
6217 } else {
6218 R__b.WriteClassBuffer(TTrigEvent::Class(),this);
6219 }
6220}
6221
6222//______________________________________________________________________________
6223void TTrigEvent::ShowMembers(TMemberInspector &R__insp)
6224{
6225 // Inspect the data members of an object of class TTrigEvent.
6226 TClass *R__cl = ::TTrigEvent::IsA();
6227 if (R__cl || R__insp.IsA()) { }
6228 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_trigData", &m_trigData);
6229 TObject::ShowMembers(R__insp);
6230}
6231
6232namespace ROOT {
6233 // Wrappers around operator new
6234 static void *new_TTrigEvent(void *p) {
6235 return p ? new(p) ::TTrigEvent : new ::TTrigEvent;
6236 }
6237 static void *newArray_TTrigEvent(Long_t nElements, void *p) {
6238 return p ? new(p) ::TTrigEvent[nElements] : new ::TTrigEvent[nElements];
6239 }
6240 // Wrapper around operator delete
6241 static void delete_TTrigEvent(void *p) {
6242 delete ((::TTrigEvent*)p);
6243 }
6244 static void deleteArray_TTrigEvent(void *p) {
6245 delete [] ((::TTrigEvent*)p);
6246 }
6247 static void destruct_TTrigEvent(void *p) {
6248 typedef ::TTrigEvent current_t;
6249 ((current_t*)p)->~current_t();
6250 }
6251} // end of namespace ROOT for class ::TTrigEvent
6252
6253//______________________________________________________________________________
6254void TTrigData::Streamer(TBuffer &R__b)
6255{
6256 // Stream an object of class TTrigData.
6257
6258 if (R__b.IsReading()) {
6259 R__b.ReadClassBuffer(TTrigData::Class(),this);
6260 } else {
6261 R__b.WriteClassBuffer(TTrigData::Class(),this);
6262 }
6263}
6264
6265//______________________________________________________________________________
6266void TTrigData::ShowMembers(TMemberInspector &R__insp)
6267{
6268 // Inspect the data members of an object of class TTrigData.
6269 TClass *R__cl = ::TTrigData::IsA();
6270 if (R__cl || R__insp.IsA()) { }
6271 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_preScale", &m_preScale);
6272 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trigcond[48]", m_trigcond);
6273 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trigChan[16]", m_trigChan);
6274 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_timeWindow", &m_timeWindow);
6275 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_Timing", &m_Timing);
6276 TObject::ShowMembers(R__insp);
6277}
6278
6279namespace ROOT {
6280 // Wrappers around operator new
6281 static void *new_TTrigData(void *p) {
6282 return p ? new(p) ::TTrigData : new ::TTrigData;
6283 }
6284 static void *newArray_TTrigData(Long_t nElements, void *p) {
6285 return p ? new(p) ::TTrigData[nElements] : new ::TTrigData[nElements];
6286 }
6287 // Wrapper around operator delete
6288 static void delete_TTrigData(void *p) {
6289 delete ((::TTrigData*)p);
6290 }
6291 static void deleteArray_TTrigData(void *p) {
6292 delete [] ((::TTrigData*)p);
6293 }
6294 static void destruct_TTrigData(void *p) {
6295 typedef ::TTrigData current_t;
6296 ((current_t*)p)->~current_t();
6297 }
6298} // end of namespace ROOT for class ::TTrigData
6299
6300//______________________________________________________________________________
6301void THltEvent::Streamer(TBuffer &R__b)
6302{
6303 // Stream an object of class THltEvent.
6304
6305 if (R__b.IsReading()) {
6306 R__b.ReadClassBuffer(THltEvent::Class(),this);
6307 } else {
6308 R__b.WriteClassBuffer(THltEvent::Class(),this);
6309 }
6310}
6311
6312//______________________________________________________________________________
6313void THltEvent::ShowMembers(TMemberInspector &R__insp)
6314{
6315 // Inspect the data members of an object of class THltEvent.
6316 TClass *R__cl = ::THltEvent::IsA();
6317 if (R__cl || R__insp.IsA()) { }
6318 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_hltRawCol", &m_hltRawCol);
6319 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_hltInf", &m_hltInf);
6320 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_dstHltInf", &m_dstHltInf);
6321 TObject::ShowMembers(R__insp);
6322}
6323
6324namespace ROOT {
6325 // Wrappers around operator new
6326 static void *new_THltEvent(void *p) {
6327 return p ? new(p) ::THltEvent : new ::THltEvent;
6328 }
6329 static void *newArray_THltEvent(Long_t nElements, void *p) {
6330 return p ? new(p) ::THltEvent[nElements] : new ::THltEvent[nElements];
6331 }
6332 // Wrapper around operator delete
6333 static void delete_THltEvent(void *p) {
6334 delete ((::THltEvent*)p);
6335 }
6336 static void deleteArray_THltEvent(void *p) {
6337 delete [] ((::THltEvent*)p);
6338 }
6339 static void destruct_THltEvent(void *p) {
6340 typedef ::THltEvent current_t;
6341 ((current_t*)p)->~current_t();
6342 }
6343} // end of namespace ROOT for class ::THltEvent
6344
6345//______________________________________________________________________________
6346void THltRaw::Streamer(TBuffer &R__b)
6347{
6348 // Stream an object of class THltRaw.
6349
6350 if (R__b.IsReading()) {
6351 R__b.ReadClassBuffer(THltRaw::Class(),this);
6352 } else {
6353 R__b.WriteClassBuffer(THltRaw::Class(),this);
6354 }
6355}
6356
6357//______________________________________________________________________________
6358void THltRaw::ShowMembers(TMemberInspector &R__insp)
6359{
6360 // Inspect the data members of an object of class THltRaw.
6361 TClass *R__cl = ::THltRaw::IsA();
6362 if (R__cl || R__insp.IsA()) { }
6363 TRawData::ShowMembers(R__insp);
6364}
6365
6366namespace ROOT {
6367 // Wrappers around operator new
6368 static void *new_THltRaw(void *p) {
6369 return p ? new(p) ::THltRaw : new ::THltRaw;
6370 }
6371 static void *newArray_THltRaw(Long_t nElements, void *p) {
6372 return p ? new(p) ::THltRaw[nElements] : new ::THltRaw[nElements];
6373 }
6374 // Wrapper around operator delete
6375 static void delete_THltRaw(void *p) {
6376 delete ((::THltRaw*)p);
6377 }
6378 static void deleteArray_THltRaw(void *p) {
6379 delete [] ((::THltRaw*)p);
6380 }
6381 static void destruct_THltRaw(void *p) {
6382 typedef ::THltRaw current_t;
6383 ((current_t*)p)->~current_t();
6384 }
6385} // end of namespace ROOT for class ::THltRaw
6386
6387//______________________________________________________________________________
6388void THltInf::Streamer(TBuffer &R__b)
6389{
6390 // Stream an object of class THltInf.
6391
6392 if (R__b.IsReading()) {
6393 R__b.ReadClassBuffer(THltInf::Class(),this);
6394 } else {
6395 R__b.WriteClassBuffer(THltInf::Class(),this);
6396 }
6397}
6398
6399//______________________________________________________________________________
6400void THltInf::ShowMembers(TMemberInspector &R__insp)
6401{
6402 // Inspect the data members of an object of class THltInf.
6403 TClass *R__cl = ::THltInf::IsA();
6404 if (R__cl || R__insp.IsA()) { }
6405 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_evtType", &m_evtType);
6406 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_algProcess", &m_algProcess);
6407 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_criTable", &m_criTable);
6408 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_verNumber", &m_verNumber);
6409 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eTotal", &m_eTotal);
6410 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_subNumber", &m_subNumber);
6411 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_conNumber", &m_conNumber);
6412 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcData", (void*)&m_mdcData);
6413 R__insp.InspectMember("vector<Int_t>", (void*)&m_mdcData, "m_mdcData.", false);
6414 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofData", (void*)&m_tofData);
6415 R__insp.InspectMember("vector<Int_t>", (void*)&m_tofData, "m_tofData.", false);
6416 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_emcData", (void*)&m_emcData);
6417 R__insp.InspectMember("vector<Int_t>", (void*)&m_emcData, "m_emcData.", false);
6418 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mucData", (void*)&m_mucData);
6419 R__insp.InspectMember("vector<Int_t>", (void*)&m_mucData, "m_mucData.", false);
6420 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_conData", (void*)&m_conData);
6421 R__insp.InspectMember("vector<Int_t>", (void*)&m_conData, "m_conData.", false);
6422 TObject::ShowMembers(R__insp);
6423}
6424
6425namespace ROOT {
6426 // Wrappers around operator new
6427 static void *new_THltInf(void *p) {
6428 return p ? new(p) ::THltInf : new ::THltInf;
6429 }
6430 static void *newArray_THltInf(Long_t nElements, void *p) {
6431 return p ? new(p) ::THltInf[nElements] : new ::THltInf[nElements];
6432 }
6433 // Wrapper around operator delete
6434 static void delete_THltInf(void *p) {
6435 delete ((::THltInf*)p);
6436 }
6437 static void deleteArray_THltInf(void *p) {
6438 delete [] ((::THltInf*)p);
6439 }
6440 static void destruct_THltInf(void *p) {
6441 typedef ::THltInf current_t;
6442 ((current_t*)p)->~current_t();
6443 }
6444} // end of namespace ROOT for class ::THltInf
6445
6446//______________________________________________________________________________
6447void TDstHltInf::Streamer(TBuffer &R__b)
6448{
6449 // Stream an object of class TDstHltInf.
6450
6451 if (R__b.IsReading()) {
6452 R__b.ReadClassBuffer(TDstHltInf::Class(),this);
6453 } else {
6454 R__b.WriteClassBuffer(TDstHltInf::Class(),this);
6455 }
6456}
6457
6458//______________________________________________________________________________
6459void TDstHltInf::ShowMembers(TMemberInspector &R__insp)
6460{
6461 // Inspect the data members of an object of class TDstHltInf.
6462 TClass *R__cl = ::TDstHltInf::IsA();
6463 if (R__cl || R__insp.IsA()) { }
6464 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_evtType", &m_evtType);
6465 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_algProcess", &m_algProcess);
6466 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_criTable", &m_criTable);
6467 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_verNumber", &m_verNumber);
6468 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eTotal", &m_eTotal);
6469 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_subNumber", &m_subNumber);
6470 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_conNumber", &m_conNumber);
6471 TObject::ShowMembers(R__insp);
6472}
6473
6474namespace ROOT {
6475 // Wrappers around operator new
6476 static void *new_TDstHltInf(void *p) {
6477 return p ? new(p) ::TDstHltInf : new ::TDstHltInf;
6478 }
6479 static void *newArray_TDstHltInf(Long_t nElements, void *p) {
6480 return p ? new(p) ::TDstHltInf[nElements] : new ::TDstHltInf[nElements];
6481 }
6482 // Wrapper around operator delete
6483 static void delete_TDstHltInf(void *p) {
6484 delete ((::TDstHltInf*)p);
6485 }
6486 static void deleteArray_TDstHltInf(void *p) {
6487 delete [] ((::TDstHltInf*)p);
6488 }
6489 static void destruct_TDstHltInf(void *p) {
6490 typedef ::TDstHltInf current_t;
6491 ((current_t*)p)->~current_t();
6492 }
6493} // end of namespace ROOT for class ::TDstHltInf
6494
6495//______________________________________________________________________________
6496void TDisTrack::Streamer(TBuffer &R__b)
6497{
6498 // Stream an object of class TDisTrack.
6499
6500 UInt_t R__s, R__c;
6501 if (R__b.IsReading()) {
6502 Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
6503 TObject::Streamer(R__b);
6504 R__b >> m_recMdcTrackCol;
6505 R__b >> m_recTofTrackCol;
6506 R__b >> m_recMdcHitCol;
6507 R__b >> m_recMucTrackCol;
6508 R__b >> m_recEmcShowerCol;
6509 R__b.CheckByteCount(R__s, R__c, TDisTrack::IsA());
6510 } else {
6511 R__c = R__b.WriteVersion(TDisTrack::IsA(), kTRUE);
6512 TObject::Streamer(R__b);
6513 R__b << m_recMdcTrackCol;
6514 R__b << m_recTofTrackCol;
6515 R__b << m_recMdcHitCol;
6516 R__b << m_recMucTrackCol;
6517 R__b << m_recEmcShowerCol;
6518 R__b.SetByteCount(R__c, kTRUE);
6519 }
6520}
6521
6522//______________________________________________________________________________
6523void TDisTrack::ShowMembers(TMemberInspector &R__insp)
6524{
6525 // Inspect the data members of an object of class TDisTrack.
6526 TClass *R__cl = ::TDisTrack::IsA();
6527 if (R__cl || R__insp.IsA()) { }
6528 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcTrackCol", &m_recMdcTrackCol);
6529 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recTofTrackCol", &m_recTofTrackCol);
6530 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcHitCol", &m_recMdcHitCol);
6531 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMucTrackCol", &m_recMucTrackCol);
6532 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recEmcShowerCol", &m_recEmcShowerCol);
6533 TObject::ShowMembers(R__insp);
6534}
6535
6536namespace ROOT {
6537 // Wrappers around operator new
6538 static void *new_TDisTrack(void *p) {
6539 return p ? new(p) ::TDisTrack : new ::TDisTrack;
6540 }
6541 static void *newArray_TDisTrack(Long_t nElements, void *p) {
6542 return p ? new(p) ::TDisTrack[nElements] : new ::TDisTrack[nElements];
6543 }
6544 // Wrapper around operator delete
6545 static void delete_TDisTrack(void *p) {
6546 delete ((::TDisTrack*)p);
6547 }
6548 static void deleteArray_TDisTrack(void *p) {
6549 delete [] ((::TDisTrack*)p);
6550 }
6551 static void destruct_TDisTrack(void *p) {
6552 typedef ::TDisTrack current_t;
6553 ((current_t*)p)->~current_t();
6554 }
6555 // Wrapper around a custom streamer member function.
6556 static void streamer_TDisTrack(TBuffer &buf, void *obj) {
6557 ((::TDisTrack*)obj)->::TDisTrack::Streamer(buf);
6558 }
6559} // end of namespace ROOT for class ::TDisTrack
6560
6561//______________________________________________________________________________
6562void TEvtRecObject::Streamer(TBuffer &R__b)
6563{
6564 // Stream an object of class TEvtRecObject.
6565
6566 if (R__b.IsReading()) {
6567 R__b.ReadClassBuffer(TEvtRecObject::Class(),this);
6568 } else {
6569 R__b.WriteClassBuffer(TEvtRecObject::Class(),this);
6570 }
6571}
6572
6573//______________________________________________________________________________
6574void TEvtRecObject::ShowMembers(TMemberInspector &R__insp)
6575{
6576 // Inspect the data members of an object of class TEvtRecObject.
6577 TClass *R__cl = ::TEvtRecObject::IsA();
6578 if (R__cl || R__insp.IsA()) { }
6579 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecEvent", &m_evtRecEvent);
6580 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecTrackCol", &m_evtRecTrackCol);
6581 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecPrimaryVertex", &m_evtRecPrimaryVertex);
6582 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecVeeVertexCol", &m_evtRecVeeVertexCol);
6583 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecPi0Col", &m_evtRecPi0Col);
6584 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecEtaToGGCol", &m_evtRecEtaToGGCol);
6585 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecDTagCol", &m_evtRecDTagCol);
6586 TObject::ShowMembers(R__insp);
6587}
6588
6589namespace ROOT {
6590 // Wrappers around operator new
6591 static void *new_TEvtRecObject(void *p) {
6592 return p ? new(p) ::TEvtRecObject : new ::TEvtRecObject;
6593 }
6594 static void *newArray_TEvtRecObject(Long_t nElements, void *p) {
6595 return p ? new(p) ::TEvtRecObject[nElements] : new ::TEvtRecObject[nElements];
6596 }
6597 // Wrapper around operator delete
6598 static void delete_TEvtRecObject(void *p) {
6599 delete ((::TEvtRecObject*)p);
6600 }
6601 static void deleteArray_TEvtRecObject(void *p) {
6602 delete [] ((::TEvtRecObject*)p);
6603 }
6604 static void destruct_TEvtRecObject(void *p) {
6605 typedef ::TEvtRecObject current_t;
6606 ((current_t*)p)->~current_t();
6607 }
6608} // end of namespace ROOT for class ::TEvtRecObject
6609
6610//______________________________________________________________________________
6611void TEvtRecEvent::Streamer(TBuffer &R__b)
6612{
6613 // Stream an object of class TEvtRecEvent.
6614
6615 if (R__b.IsReading()) {
6616 R__b.ReadClassBuffer(TEvtRecEvent::Class(),this);
6617 } else {
6618 R__b.WriteClassBuffer(TEvtRecEvent::Class(),this);
6619 }
6620}
6621
6622//______________________________________________________________________________
6623void TEvtRecEvent::ShowMembers(TMemberInspector &R__insp)
6624{
6625 // Inspect the data members of an object of class TEvtRecEvent.
6626 TClass *R__cl = ::TEvtRecEvent::IsA();
6627 if (R__cl || R__insp.IsA()) { }
6628 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tottks", &m_tottks);
6629 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nchrg", &m_nchrg);
6630 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nneu", &m_nneu);
6631 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nvee", &m_nvee);
6632 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_npi0", &m_npi0);
6633 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_neta", &m_neta);
6634 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndtag", &m_ndtag);
6635 TObject::ShowMembers(R__insp);
6636}
6637
6638namespace ROOT {
6639 // Wrappers around operator new
6640 static void *new_TEvtRecEvent(void *p) {
6641 return p ? new(p) ::TEvtRecEvent : new ::TEvtRecEvent;
6642 }
6643 static void *newArray_TEvtRecEvent(Long_t nElements, void *p) {
6644 return p ? new(p) ::TEvtRecEvent[nElements] : new ::TEvtRecEvent[nElements];
6645 }
6646 // Wrapper around operator delete
6647 static void delete_TEvtRecEvent(void *p) {
6648 delete ((::TEvtRecEvent*)p);
6649 }
6650 static void deleteArray_TEvtRecEvent(void *p) {
6651 delete [] ((::TEvtRecEvent*)p);
6652 }
6653 static void destruct_TEvtRecEvent(void *p) {
6654 typedef ::TEvtRecEvent current_t;
6655 ((current_t*)p)->~current_t();
6656 }
6657} // end of namespace ROOT for class ::TEvtRecEvent
6658
6659//______________________________________________________________________________
6660void TEvtRecTrack::Streamer(TBuffer &R__b)
6661{
6662 // Stream an object of class TEvtRecTrack.
6663
6664 if (R__b.IsReading()) {
6665 R__b.ReadClassBuffer(TEvtRecTrack::Class(),this);
6666 } else {
6667 R__b.WriteClassBuffer(TEvtRecTrack::Class(),this);
6668 }
6669}
6670
6671//______________________________________________________________________________
6672void TEvtRecTrack::ShowMembers(TMemberInspector &R__insp)
6673{
6674 // Inspect the data members of an object of class TEvtRecTrack.
6675 TClass *R__cl = ::TEvtRecTrack::IsA();
6676 if (R__cl || R__insp.IsA()) { }
6677 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
6678 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_partId", &m_partId);
6679 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_quality", &m_quality);
6680 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcTrackId", &m_mdcTrackId);
6681 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcKalTrackId", &m_mdcKalTrackId);
6682 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcDedxId", &m_mdcDedxId);
6683 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_extTrackId", &m_extTrackId);
6684 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_emcShowerId", &m_emcShowerId);
6685 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mucTrackId", &m_mucTrackId);
6686 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofTrackIds", (void*)&m_tofTrackIds);
6687 R__insp.InspectMember("vector<Int_t>", (void*)&m_tofTrackIds, "m_tofTrackIds.", false);
6688 TObject::ShowMembers(R__insp);
6689}
6690
6691namespace ROOT {
6692 // Wrappers around operator new
6693 static void *new_TEvtRecTrack(void *p) {
6694 return p ? new(p) ::TEvtRecTrack : new ::TEvtRecTrack;
6695 }
6696 static void *newArray_TEvtRecTrack(Long_t nElements, void *p) {
6697 return p ? new(p) ::TEvtRecTrack[nElements] : new ::TEvtRecTrack[nElements];
6698 }
6699 // Wrapper around operator delete
6700 static void delete_TEvtRecTrack(void *p) {
6701 delete ((::TEvtRecTrack*)p);
6702 }
6703 static void deleteArray_TEvtRecTrack(void *p) {
6704 delete [] ((::TEvtRecTrack*)p);
6705 }
6706 static void destruct_TEvtRecTrack(void *p) {
6707 typedef ::TEvtRecTrack current_t;
6708 ((current_t*)p)->~current_t();
6709 }
6710} // end of namespace ROOT for class ::TEvtRecTrack
6711
6712//______________________________________________________________________________
6713void TEvtRecPrimaryVertex::Streamer(TBuffer &R__b)
6714{
6715 // Stream an object of class TEvtRecPrimaryVertex.
6716
6717 if (R__b.IsReading()) {
6718 R__b.ReadClassBuffer(TEvtRecPrimaryVertex::Class(),this);
6719 } else {
6720 R__b.WriteClassBuffer(TEvtRecPrimaryVertex::Class(),this);
6721 }
6722}
6723
6724//______________________________________________________________________________
6725void TEvtRecPrimaryVertex::ShowMembers(TMemberInspector &R__insp)
6726{
6727 // Inspect the data members of an object of class TEvtRecPrimaryVertex.
6728 TClass *R__cl = ::TEvtRecPrimaryVertex::IsA();
6729 if (R__cl || R__insp.IsA()) { }
6730 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_isValid", &m_isValid);
6731 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nTracks", &m_nTracks);
6732 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIdList", (void*)&m_trackIdList);
6733 R__insp.InspectMember("vector<Int_t>", (void*)&m_trackIdList, "m_trackIdList.", false);
6734 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
6735 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndof", &m_ndof);
6736 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fitMethod", &m_fitMethod);
6737 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vtx[3]", m_vtx);
6738 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_Evtx[6]", m_Evtx);
6739 TObject::ShowMembers(R__insp);
6740}
6741
6742namespace ROOT {
6743 // Wrappers around operator new
6744 static void *new_TEvtRecPrimaryVertex(void *p) {
6745 return p ? new(p) ::TEvtRecPrimaryVertex : new ::TEvtRecPrimaryVertex;
6746 }
6747 static void *newArray_TEvtRecPrimaryVertex(Long_t nElements, void *p) {
6748 return p ? new(p) ::TEvtRecPrimaryVertex[nElements] : new ::TEvtRecPrimaryVertex[nElements];
6749 }
6750 // Wrapper around operator delete
6751 static void delete_TEvtRecPrimaryVertex(void *p) {
6752 delete ((::TEvtRecPrimaryVertex*)p);
6753 }
6754 static void deleteArray_TEvtRecPrimaryVertex(void *p) {
6755 delete [] ((::TEvtRecPrimaryVertex*)p);
6756 }
6757 static void destruct_TEvtRecPrimaryVertex(void *p) {
6758 typedef ::TEvtRecPrimaryVertex current_t;
6759 ((current_t*)p)->~current_t();
6760 }
6761} // end of namespace ROOT for class ::TEvtRecPrimaryVertex
6762
6763//______________________________________________________________________________
6764void TEvtRecVeeVertex::Streamer(TBuffer &R__b)
6765{
6766 // Stream an object of class TEvtRecVeeVertex.
6767
6768 if (R__b.IsReading()) {
6769 R__b.ReadClassBuffer(TEvtRecVeeVertex::Class(),this);
6770 } else {
6771 R__b.WriteClassBuffer(TEvtRecVeeVertex::Class(),this);
6772 }
6773}
6774
6775//______________________________________________________________________________
6776void TEvtRecVeeVertex::ShowMembers(TMemberInspector &R__insp)
6777{
6778 // Inspect the data members of an object of class TEvtRecVeeVertex.
6779 TClass *R__cl = ::TEvtRecVeeVertex::IsA();
6780 if (R__cl || R__insp.IsA()) { }
6781 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vertexId", &m_vertexId);
6782 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vertexType", &m_vertexType);
6783 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
6784 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndof", &m_ndof);
6785 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mass", &m_mass);
6786 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_w[7]", m_w);
6787 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_Ew[28]", m_Ew);
6788 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pair[2]", m_pair);
6789 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nCharge", &m_nCharge);
6790 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nTracks", &m_nTracks);
6791 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_daughter[2]", m_daughter);
6792 TObject::ShowMembers(R__insp);
6793}
6794
6795namespace ROOT {
6796 // Wrappers around operator new
6797 static void *new_TEvtRecVeeVertex(void *p) {
6798 return p ? new(p) ::TEvtRecVeeVertex : new ::TEvtRecVeeVertex;
6799 }
6800 static void *newArray_TEvtRecVeeVertex(Long_t nElements, void *p) {
6801 return p ? new(p) ::TEvtRecVeeVertex[nElements] : new ::TEvtRecVeeVertex[nElements];
6802 }
6803 // Wrapper around operator delete
6804 static void delete_TEvtRecVeeVertex(void *p) {
6805 delete ((::TEvtRecVeeVertex*)p);
6806 }
6807 static void deleteArray_TEvtRecVeeVertex(void *p) {
6808 delete [] ((::TEvtRecVeeVertex*)p);
6809 }
6810 static void destruct_TEvtRecVeeVertex(void *p) {
6811 typedef ::TEvtRecVeeVertex current_t;
6812 ((current_t*)p)->~current_t();
6813 }
6814} // end of namespace ROOT for class ::TEvtRecVeeVertex
6815
6816//______________________________________________________________________________
6817void TEvtRecPi0::Streamer(TBuffer &R__b)
6818{
6819 // Stream an object of class TEvtRecPi0.
6820
6821 if (R__b.IsReading()) {
6822 R__b.ReadClassBuffer(TEvtRecPi0::Class(),this);
6823 } else {
6824 R__b.WriteClassBuffer(TEvtRecPi0::Class(),this);
6825 }
6826}
6827
6828//______________________________________________________________________________
6829void TEvtRecPi0::ShowMembers(TMemberInspector &R__insp)
6830{
6831 // Inspect the data members of an object of class TEvtRecPi0.
6832 TClass *R__cl = ::TEvtRecPi0::IsA();
6833 if (R__cl || R__insp.IsA()) { }
6834 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_unconMass", &m_unconMass);
6835 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chisq", &m_chisq);
6836 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPx", &m_hiPx);
6837 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPy", &m_hiPy);
6838 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPz", &m_hiPz);
6839 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPe", &m_hiPe);
6840 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPx", &m_loPx);
6841 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPy", &m_loPy);
6842 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPz", &m_loPz);
6843 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPe", &m_loPe);
6844 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiEnGamma", &m_hiEnGamma);
6845 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loEnGamma", &m_loEnGamma);
6846 TObject::ShowMembers(R__insp);
6847}
6848
6849namespace ROOT {
6850 // Wrappers around operator new
6851 static void *new_TEvtRecPi0(void *p) {
6852 return p ? new(p) ::TEvtRecPi0 : new ::TEvtRecPi0;
6853 }
6854 static void *newArray_TEvtRecPi0(Long_t nElements, void *p) {
6855 return p ? new(p) ::TEvtRecPi0[nElements] : new ::TEvtRecPi0[nElements];
6856 }
6857 // Wrapper around operator delete
6858 static void delete_TEvtRecPi0(void *p) {
6859 delete ((::TEvtRecPi0*)p);
6860 }
6861 static void deleteArray_TEvtRecPi0(void *p) {
6862 delete [] ((::TEvtRecPi0*)p);
6863 }
6864 static void destruct_TEvtRecPi0(void *p) {
6865 typedef ::TEvtRecPi0 current_t;
6866 ((current_t*)p)->~current_t();
6867 }
6868} // end of namespace ROOT for class ::TEvtRecPi0
6869
6870//______________________________________________________________________________
6871void TEvtRecEtaToGG::Streamer(TBuffer &R__b)
6872{
6873 // Stream an object of class TEvtRecEtaToGG.
6874
6875 if (R__b.IsReading()) {
6876 R__b.ReadClassBuffer(TEvtRecEtaToGG::Class(),this);
6877 } else {
6878 R__b.WriteClassBuffer(TEvtRecEtaToGG::Class(),this);
6879 }
6880}
6881
6882//______________________________________________________________________________
6883void TEvtRecEtaToGG::ShowMembers(TMemberInspector &R__insp)
6884{
6885 // Inspect the data members of an object of class TEvtRecEtaToGG.
6886 TClass *R__cl = ::TEvtRecEtaToGG::IsA();
6887 if (R__cl || R__insp.IsA()) { }
6888 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_unconMass", &m_unconMass);
6889 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chisq", &m_chisq);
6890 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPx", &m_hiPx);
6891 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPy", &m_hiPy);
6892 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPz", &m_hiPz);
6893 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPe", &m_hiPe);
6894 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPx", &m_loPx);
6895 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPy", &m_loPy);
6896 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPz", &m_loPz);
6897 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPe", &m_loPe);
6898 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiEnGamma", &m_hiEnGamma);
6899 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loEnGamma", &m_loEnGamma);
6900 TObject::ShowMembers(R__insp);
6901}
6902
6903namespace ROOT {
6904 // Wrappers around operator new
6905 static void *new_TEvtRecEtaToGG(void *p) {
6906 return p ? new(p) ::TEvtRecEtaToGG : new ::TEvtRecEtaToGG;
6907 }
6908 static void *newArray_TEvtRecEtaToGG(Long_t nElements, void *p) {
6909 return p ? new(p) ::TEvtRecEtaToGG[nElements] : new ::TEvtRecEtaToGG[nElements];
6910 }
6911 // Wrapper around operator delete
6912 static void delete_TEvtRecEtaToGG(void *p) {
6913 delete ((::TEvtRecEtaToGG*)p);
6914 }
6915 static void deleteArray_TEvtRecEtaToGG(void *p) {
6916 delete [] ((::TEvtRecEtaToGG*)p);
6917 }
6918 static void destruct_TEvtRecEtaToGG(void *p) {
6919 typedef ::TEvtRecEtaToGG current_t;
6920 ((current_t*)p)->~current_t();
6921 }
6922} // end of namespace ROOT for class ::TEvtRecEtaToGG
6923
6924//______________________________________________________________________________
6925void TEvtRecDTag::Streamer(TBuffer &R__b)
6926{
6927 // Stream an object of class TEvtRecDTag.
6928
6929 if (R__b.IsReading()) {
6930 R__b.ReadClassBuffer(TEvtRecDTag::Class(),this);
6931 } else {
6932 R__b.WriteClassBuffer(TEvtRecDTag::Class(),this);
6933 }
6934}
6935
6936//______________________________________________________________________________
6937void TEvtRecDTag::ShowMembers(TMemberInspector &R__insp)
6938{
6939 // Inspect the data members of an object of class TEvtRecDTag.
6940 TClass *R__cl = ::TEvtRecDTag::IsA();
6941 if (R__cl || R__insp.IsA()) { }
6942 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_decayMode", &m_decayMode);
6943 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_type", &m_type);
6944 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_beamE", &m_beamE);
6945 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mass", &m_mass);
6946 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mBC", &m_mBC);
6947 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_deltaE", &m_deltaE);
6948 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_charge", &m_charge);
6949 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_charm", &m_charm);
6950 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numOfChildren", &m_numOfChildren);
6951 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
6952 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
6953 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
6954 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pe", &m_pe);
6955 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tracks", (void*)&m_tracks);
6956 R__insp.InspectMember("vector<Int_t>", (void*)&m_tracks, "m_tracks.", false);
6957 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_showers", (void*)&m_showers);
6958 R__insp.InspectMember("vector<Int_t>", (void*)&m_showers, "m_showers.", false);
6959 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_otherTracks", (void*)&m_otherTracks);
6960 R__insp.InspectMember("vector<Int_t>", (void*)&m_otherTracks, "m_otherTracks.", false);
6961 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_otherShowers", (void*)&m_otherShowers);
6962 R__insp.InspectMember("vector<Int_t>", (void*)&m_otherShowers, "m_otherShowers.", false);
6963 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pionId", (void*)&m_pionId);
6964 R__insp.InspectMember("vector<Int_t>", (void*)&m_pionId, "m_pionId.", false);
6965 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kaonId", (void*)&m_kaonId);
6966 R__insp.InspectMember("vector<Int_t>", (void*)&m_kaonId, "m_kaonId.", false);
6967 TObject::ShowMembers(R__insp);
6968}
6969
6970namespace ROOT {
6971 // Wrappers around operator new
6972 static void *new_TEvtRecDTag(void *p) {
6973 return p ? new(p) ::TEvtRecDTag : new ::TEvtRecDTag;
6974 }
6975 static void *newArray_TEvtRecDTag(Long_t nElements, void *p) {
6976 return p ? new(p) ::TEvtRecDTag[nElements] : new ::TEvtRecDTag[nElements];
6977 }
6978 // Wrapper around operator delete
6979 static void delete_TEvtRecDTag(void *p) {
6980 delete ((::TEvtRecDTag*)p);
6981 }
6982 static void deleteArray_TEvtRecDTag(void *p) {
6983 delete [] ((::TEvtRecDTag*)p);
6984 }
6985 static void destruct_TEvtRecDTag(void *p) {
6986 typedef ::TEvtRecDTag current_t;
6987 ((current_t*)p)->~current_t();
6988 }
6989} // end of namespace ROOT for class ::TEvtRecDTag
6990
6991//______________________________________________________________________________
6992void TMcHitEvent::Streamer(TBuffer &R__b)
6993{
6994 // Stream an object of class TMcHitEvent.
6995
6996 if (R__b.IsReading()) {
6997 R__b.ReadClassBuffer(TMcHitEvent::Class(),this);
6998 } else {
6999 R__b.WriteClassBuffer(TMcHitEvent::Class(),this);
7000 }
7001}
7002
7003//______________________________________________________________________________
7004void TMcHitEvent::ShowMembers(TMemberInspector &R__insp)
7005{
7006 // Inspect the data members of an object of class TMcHitEvent.
7007 TClass *R__cl = ::TMcHitEvent::IsA();
7008 if (R__cl || R__insp.IsA()) { }
7009 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tTofMcHitCol", &m_tTofMcHitCol);
7010 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tMdcMcHitCol", &m_tMdcMcHitCol);
7011 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tEmcMcDigiCol", &m_tEmcMcDigiCol);
7012 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_beamTime", &m_beamTime);
7013 TObject::ShowMembers(R__insp);
7014}
7015
7016namespace ROOT {
7017 // Wrappers around operator new
7018 static void *new_TMcHitEvent(void *p) {
7019 return p ? new(p) ::TMcHitEvent : new ::TMcHitEvent;
7020 }
7021 static void *newArray_TMcHitEvent(Long_t nElements, void *p) {
7022 return p ? new(p) ::TMcHitEvent[nElements] : new ::TMcHitEvent[nElements];
7023 }
7024 // Wrapper around operator delete
7025 static void delete_TMcHitEvent(void *p) {
7026 delete ((::TMcHitEvent*)p);
7027 }
7028 static void deleteArray_TMcHitEvent(void *p) {
7029 delete [] ((::TMcHitEvent*)p);
7030 }
7031 static void destruct_TMcHitEvent(void *p) {
7032 typedef ::TMcHitEvent current_t;
7033 ((current_t*)p)->~current_t();
7034 }
7035} // end of namespace ROOT for class ::TMcHitEvent
7036
7037//______________________________________________________________________________
7038void TMcDigiEmc::Streamer(TBuffer &R__b)
7039{
7040 // Stream an object of class TMcDigiEmc.
7041
7042 if (R__b.IsReading()) {
7043 R__b.ReadClassBuffer(TMcDigiEmc::Class(),this);
7044 } else {
7045 R__b.WriteClassBuffer(TMcDigiEmc::Class(),this);
7046 }
7047}
7048
7049//______________________________________________________________________________
7050void TMcDigiEmc::ShowMembers(TMemberInspector &R__insp)
7051{
7052 // Inspect the data members of an object of class TMcDigiEmc.
7053 TClass *R__cl = ::TMcDigiEmc::IsA();
7054 if (R__cl || R__insp.IsA()) { }
7055 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_partId", &m_partId);
7056 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nTheta", &m_nTheta);
7057 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nPhi", &m_nPhi);
7058 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_energy", &m_energy);
7059 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
7060 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
7061 TObject::ShowMembers(R__insp);
7062}
7063
7064namespace ROOT {
7065 // Wrappers around operator new
7066 static void *new_TMcDigiEmc(void *p) {
7067 return p ? new(p) ::TMcDigiEmc : new ::TMcDigiEmc;
7068 }
7069 static void *newArray_TMcDigiEmc(Long_t nElements, void *p) {
7070 return p ? new(p) ::TMcDigiEmc[nElements] : new ::TMcDigiEmc[nElements];
7071 }
7072 // Wrapper around operator delete
7073 static void delete_TMcDigiEmc(void *p) {
7074 delete ((::TMcDigiEmc*)p);
7075 }
7076 static void deleteArray_TMcDigiEmc(void *p) {
7077 delete [] ((::TMcDigiEmc*)p);
7078 }
7079 static void destruct_TMcDigiEmc(void *p) {
7080 typedef ::TMcDigiEmc current_t;
7081 ((current_t*)p)->~current_t();
7082 }
7083} // end of namespace ROOT for class ::TMcDigiEmc
7084
7085//______________________________________________________________________________
7086void TMcHitTof::Streamer(TBuffer &R__b)
7087{
7088 // Stream an object of class TMcHitTof.
7089
7090 if (R__b.IsReading()) {
7091 R__b.ReadClassBuffer(TMcHitTof::Class(),this);
7092 } else {
7093 R__b.WriteClassBuffer(TMcHitTof::Class(),this);
7094 }
7095}
7096
7097//______________________________________________________________________________
7098void TMcHitTof::ShowMembers(TMemberInspector &R__insp)
7099{
7100 // Inspect the data members of an object of class TMcHitTof.
7101 TClass *R__cl = ::TMcHitTof::IsA();
7102 if (R__cl || R__insp.IsA()) { }
7103 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
7104 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_g4Index", &m_g4Index);
7105 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_partId", &m_partId);
7106 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_scinNb", &m_scinNb);
7107 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_edep", &m_edep);
7108 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stepL", &m_stepL);
7109 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackL", &m_trackL);
7110 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pos", &m_pos);
7111 R__insp.InspectMember(m_pos, "m_pos.");
7112 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
7113 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_deltaT", &m_deltaT);
7114 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pDirection", &m_pDirection);
7115 R__insp.InspectMember(m_pDirection, "m_pDirection.");
7116 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_momentum", &m_momentum);
7117 R__insp.InspectMember(m_momentum, "m_momentum.");
7118 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_charge", &m_charge);
7119 TObject::ShowMembers(R__insp);
7120}
7121
7122namespace ROOT {
7123 // Wrappers around operator new
7124 static void *new_TMcHitTof(void *p) {
7125 return p ? new(p) ::TMcHitTof : new ::TMcHitTof;
7126 }
7127 static void *newArray_TMcHitTof(Long_t nElements, void *p) {
7128 return p ? new(p) ::TMcHitTof[nElements] : new ::TMcHitTof[nElements];
7129 }
7130 // Wrapper around operator delete
7131 static void delete_TMcHitTof(void *p) {
7132 delete ((::TMcHitTof*)p);
7133 }
7134 static void deleteArray_TMcHitTof(void *p) {
7135 delete [] ((::TMcHitTof*)p);
7136 }
7137 static void destruct_TMcHitTof(void *p) {
7138 typedef ::TMcHitTof current_t;
7139 ((current_t*)p)->~current_t();
7140 }
7141} // end of namespace ROOT for class ::TMcHitTof
7142
7143//______________________________________________________________________________
7144void TMcHitMdc::Streamer(TBuffer &R__b)
7145{
7146 // Stream an object of class TMcHitMdc.
7147
7148 if (R__b.IsReading()) {
7149 R__b.ReadClassBuffer(TMcHitMdc::Class(),this);
7150 } else {
7151 R__b.WriteClassBuffer(TMcHitMdc::Class(),this);
7152 }
7153}
7154
7155//______________________________________________________________________________
7156void TMcHitMdc::ShowMembers(TMemberInspector &R__insp)
7157{
7158 // Inspect the data members of an object of class TMcHitMdc.
7159 TClass *R__cl = ::TMcHitMdc::IsA();
7160 if (R__cl || R__insp.IsA()) { }
7161 R__insp.Inspect(R__cl, R__insp.GetParent(), "trackID", &trackID);
7162 R__insp.Inspect(R__cl, R__insp.GetParent(), "layerNo", &layerNo);
7163 R__insp.Inspect(R__cl, R__insp.GetParent(), "cellNo", &cellNo);
7164 R__insp.Inspect(R__cl, R__insp.GetParent(), "edep", &edep);
7165 R__insp.Inspect(R__cl, R__insp.GetParent(), "pos", &pos);
7166 R__insp.InspectMember(pos, "pos.");
7167 R__insp.Inspect(R__cl, R__insp.GetParent(), "driftD", &driftD);
7168 R__insp.Inspect(R__cl, R__insp.GetParent(), "driftT", &driftT);
7169 R__insp.Inspect(R__cl, R__insp.GetParent(), "globalT", &globalT);
7170 R__insp.Inspect(R__cl, R__insp.GetParent(), "theta", &theta);
7171 R__insp.Inspect(R__cl, R__insp.GetParent(), "enterAngle", &enterAngle);
7172 R__insp.Inspect(R__cl, R__insp.GetParent(), "posFlag", &posFlag);
7173 TObject::ShowMembers(R__insp);
7174}
7175
7176namespace ROOT {
7177 // Wrappers around operator new
7178 static void *new_TMcHitMdc(void *p) {
7179 return p ? new(p) ::TMcHitMdc : new ::TMcHitMdc;
7180 }
7181 static void *newArray_TMcHitMdc(Long_t nElements, void *p) {
7182 return p ? new(p) ::TMcHitMdc[nElements] : new ::TMcHitMdc[nElements];
7183 }
7184 // Wrapper around operator delete
7185 static void delete_TMcHitMdc(void *p) {
7186 delete ((::TMcHitMdc*)p);
7187 }
7188 static void deleteArray_TMcHitMdc(void *p) {
7189 delete [] ((::TMcHitMdc*)p);
7190 }
7191 static void destruct_TMcHitMdc(void *p) {
7192 typedef ::TMcHitMdc current_t;
7193 ((current_t*)p)->~current_t();
7194 }
7195} // end of namespace ROOT for class ::TMcHitMdc
7196
7197//______________________________________________________________________________
7198void TJobInfo::Streamer(TBuffer &R__b)
7199{
7200 // Stream an object of class TJobInfo.
7201
7202 if (R__b.IsReading()) {
7203 R__b.ReadClassBuffer(TJobInfo::Class(),this);
7204 } else {
7205 R__b.WriteClassBuffer(TJobInfo::Class(),this);
7206 }
7207}
7208
7209//______________________________________________________________________________
7210void TJobInfo::ShowMembers(TMemberInspector &R__insp)
7211{
7212 // Inspect the data members of an object of class TJobInfo.
7213 TClass *R__cl = ::TJobInfo::IsA();
7214 if (R__cl || R__insp.IsA()) { }
7215 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_decayOptions", (void*)&m_decayOptions);
7216 R__insp.InspectMember("string", (void*)&m_decayOptions, "m_decayOptions.", false);
7217 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_bossVer", (void*)&m_bossVer);
7218 R__insp.InspectMember("string", (void*)&m_bossVer, "m_bossVer.", false);
7219 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_jobOptions", (void*)&m_jobOptions);
7220 R__insp.InspectMember("vector<string>", (void*)&m_jobOptions, "m_jobOptions.", false);
7221 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_totEvtNo", (void*)&m_totEvtNo);
7222 R__insp.InspectMember("vector<int>", (void*)&m_totEvtNo, "m_totEvtNo.", false);
7223 TObject::ShowMembers(R__insp);
7224}
7225
7226namespace ROOT {
7227 // Wrappers around operator new
7228 static void *new_TJobInfo(void *p) {
7229 return p ? new(p) ::TJobInfo : new ::TJobInfo;
7230 }
7231 static void *newArray_TJobInfo(Long_t nElements, void *p) {
7232 return p ? new(p) ::TJobInfo[nElements] : new ::TJobInfo[nElements];
7233 }
7234 // Wrapper around operator delete
7235 static void delete_TJobInfo(void *p) {
7236 delete ((::TJobInfo*)p);
7237 }
7238 static void deleteArray_TJobInfo(void *p) {
7239 delete [] ((::TJobInfo*)p);
7240 }
7241 static void destruct_TJobInfo(void *p) {
7242 typedef ::TJobInfo current_t;
7243 ((current_t*)p)->~current_t();
7244 }
7245} // end of namespace ROOT for class ::TJobInfo
7246
7247//______________________________________________________________________________
7248void TBossFullEvent::ShowMembers(TMemberInspector &R__insp)
7249{
7250 // Inspect the data members of an object of class TBossFullEvent.
7251 TClass *R__cl = ::TBossFullEvent::IsA();
7252 if (R__cl || R__insp.IsA()) { }
7253 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mask", &m_mask);
7254 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_EvtHeader", &m_EvtHeader);
7255 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_digiEvt", &m_digiEvt);
7256 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_dstEvt", &m_dstEvt);
7257 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mcEvt", &m_mcEvt);
7258 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_trigEvt", &m_trigEvt);
7259 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_hltEvt", &m_hltEvt);
7260 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_rectrackEvt", &m_rectrackEvt);
7261 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecObject", &m_evtRecObject);
7262 TObject::ShowMembers(R__insp);
7263}
7264
7265namespace ROOT {
7266 // Wrappers around operator new
7267 static void *new_TBossFullEvent(void *p) {
7268 return p ? new(p) ::TBossFullEvent : new ::TBossFullEvent;
7269 }
7270 static void *newArray_TBossFullEvent(Long_t nElements, void *p) {
7271 return p ? new(p) ::TBossFullEvent[nElements] : new ::TBossFullEvent[nElements];
7272 }
7273 // Wrapper around operator delete
7274 static void delete_TBossFullEvent(void *p) {
7275 delete ((::TBossFullEvent*)p);
7276 }
7277 static void deleteArray_TBossFullEvent(void *p) {
7278 delete [] ((::TBossFullEvent*)p);
7279 }
7280 static void destruct_TBossFullEvent(void *p) {
7281 typedef ::TBossFullEvent current_t;
7282 ((current_t*)p)->~current_t();
7283 }
7284 // Wrapper around a custom streamer member function.
7285 static void streamer_TBossFullEvent(TBuffer &buf, void *obj) {
7286 ((::TBossFullEvent*)obj)->::TBossFullEvent::Streamer(buf);
7287 }
7288} // end of namespace ROOT for class ::TBossFullEvent
7289
7290namespace ROOT {
7291 void maplEintcOdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
7292 static void maplEintcOdoublegR_Dictionary();
7293 static void *new_maplEintcOdoublegR(void *p = 0);
7294 static void *newArray_maplEintcOdoublegR(Long_t size, void *p);
7295 static void delete_maplEintcOdoublegR(void *p);
7296 static void deleteArray_maplEintcOdoublegR(void *p);
7297 static void destruct_maplEintcOdoublegR(void *p);
7298
7299 // Function generating the singleton type initializer
7300 static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,double>*)
7301 {
7302 map<int,double> *ptr = 0;
7303 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,double>),0);
7304 static ::ROOT::TGenericClassInfo
7305 instance("map<int,double>", -2, "prec_stl/map", 63,
7306 typeid(map<int,double>), DefineBehavior(ptr, ptr),
7307 0, &maplEintcOdoublegR_Dictionary, isa_proxy, 0,
7308 sizeof(map<int,double>) );
7309 instance.SetNew(&new_maplEintcOdoublegR);
7310 instance.SetNewArray(&newArray_maplEintcOdoublegR);
7311 instance.SetDelete(&delete_maplEintcOdoublegR);
7312 instance.SetDeleteArray(&deleteArray_maplEintcOdoublegR);
7313 instance.SetDestructor(&destruct_maplEintcOdoublegR);
7314 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<int,double> >()));
7315 return &instance;
7316 }
7317 // Static variable to force the class initialization
7318 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<int,double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7319
7320 // Dictionary for non-ClassDef classes
7321 static void maplEintcOdoublegR_Dictionary() {
7322 ::ROOT::GenerateInitInstanceLocal((const map<int,double>*)0x0)->GetClass();
7323 }
7324
7325} // end of namespace ROOT
7326
7327namespace ROOT {
7328 // Wrappers around operator new
7329 static void *new_maplEintcOdoublegR(void *p) {
7330 return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,double> : new map<int,double>;
7331 }
7332 static void *newArray_maplEintcOdoublegR(Long_t nElements, void *p) {
7333 return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,double>[nElements] : new map<int,double>[nElements];
7334 }
7335 // Wrapper around operator delete
7336 static void delete_maplEintcOdoublegR(void *p) {
7337 delete ((map<int,double>*)p);
7338 }
7339 static void deleteArray_maplEintcOdoublegR(void *p) {
7340 delete [] ((map<int,double>*)p);
7341 }
7342 static void destruct_maplEintcOdoublegR(void *p) {
7343 typedef map<int,double> current_t;
7344 ((current_t*)p)->~current_t();
7345 }
7346} // end of namespace ROOT for class map<int,double>
7347
7348namespace ROOT {
7349 void multimaplEintcOintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7350 static void multimaplEintcOintgR_Dictionary();
7351 static void *new_multimaplEintcOintgR(void *p = 0);
7352 static void *newArray_multimaplEintcOintgR(Long_t size, void *p);
7353 static void delete_multimaplEintcOintgR(void *p);
7354 static void deleteArray_multimaplEintcOintgR(void *p);
7355 static void destruct_multimaplEintcOintgR(void *p);
7356
7357 // Function generating the singleton type initializer
7358 static TGenericClassInfo *GenerateInitInstanceLocal(const multimap<int,int>*)
7359 {
7360 multimap<int,int> *ptr = 0;
7361 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(multimap<int,int>),0);
7362 static ::ROOT::TGenericClassInfo
7363 instance("multimap<int,int>", -2, "prec_stl/multimap", 63,
7364 typeid(multimap<int,int>), DefineBehavior(ptr, ptr),
7365 0, &multimaplEintcOintgR_Dictionary, isa_proxy, 0,
7366 sizeof(multimap<int,int>) );
7367 instance.SetNew(&new_multimaplEintcOintgR);
7368 instance.SetNewArray(&newArray_multimaplEintcOintgR);
7369 instance.SetDelete(&delete_multimaplEintcOintgR);
7370 instance.SetDeleteArray(&deleteArray_multimaplEintcOintgR);
7371 instance.SetDestructor(&destruct_multimaplEintcOintgR);
7372 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< multimap<int,int> >()));
7373 return &instance;
7374 }
7375 // Static variable to force the class initialization
7376 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const multimap<int,int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7377
7378 // Dictionary for non-ClassDef classes
7379 static void multimaplEintcOintgR_Dictionary() {
7380 ::ROOT::GenerateInitInstanceLocal((const multimap<int,int>*)0x0)->GetClass();
7381 }
7382
7383} // end of namespace ROOT
7384
7385namespace ROOT {
7386 // Wrappers around operator new
7387 static void *new_multimaplEintcOintgR(void *p) {
7388 return p ? ::new((::ROOT::TOperatorNewHelper*)p) multimap<int,int> : new multimap<int,int>;
7389 }
7390 static void *newArray_multimaplEintcOintgR(Long_t nElements, void *p) {
7391 return p ? ::new((::ROOT::TOperatorNewHelper*)p) multimap<int,int>[nElements] : new multimap<int,int>[nElements];
7392 }
7393 // Wrapper around operator delete
7394 static void delete_multimaplEintcOintgR(void *p) {
7395 delete ((multimap<int,int>*)p);
7396 }
7397 static void deleteArray_multimaplEintcOintgR(void *p) {
7398 delete [] ((multimap<int,int>*)p);
7399 }
7400 static void destruct_multimaplEintcOintgR(void *p) {
7401 typedef multimap<int,int> current_t;
7402 ((current_t*)p)->~current_t();
7403 }
7404} // end of namespace ROOT for class multimap<int,int>
7405
7406namespace ROOT {
7407 void vectorlETStringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7408 static void vectorlETStringgR_Dictionary();
7409 static void *new_vectorlETStringgR(void *p = 0);
7410 static void *newArray_vectorlETStringgR(Long_t size, void *p);
7411 static void delete_vectorlETStringgR(void *p);
7412 static void deleteArray_vectorlETStringgR(void *p);
7413 static void destruct_vectorlETStringgR(void *p);
7414
7415 // Function generating the singleton type initializer
7416 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TString>*)
7417 {
7418 vector<TString> *ptr = 0;
7419 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TString>),0);
7420 static ::ROOT::TGenericClassInfo
7421 instance("vector<TString>", -2, "prec_stl/vector", 49,
7422 typeid(vector<TString>), DefineBehavior(ptr, ptr),
7423 0, &vectorlETStringgR_Dictionary, isa_proxy, 0,
7424 sizeof(vector<TString>) );
7425 instance.SetNew(&new_vectorlETStringgR);
7426 instance.SetNewArray(&newArray_vectorlETStringgR);
7427 instance.SetDelete(&delete_vectorlETStringgR);
7428 instance.SetDeleteArray(&deleteArray_vectorlETStringgR);
7429 instance.SetDestructor(&destruct_vectorlETStringgR);
7430 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TString> >()));
7431 return &instance;
7432 }
7433 // Static variable to force the class initialization
7434 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TString>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7435
7436 // Dictionary for non-ClassDef classes
7437 static void vectorlETStringgR_Dictionary() {
7438 ::ROOT::GenerateInitInstanceLocal((const vector<TString>*)0x0)->GetClass();
7439 }
7440
7441} // end of namespace ROOT
7442
7443namespace ROOT {
7444 // Wrappers around operator new
7445 static void *new_vectorlETStringgR(void *p) {
7446 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString> : new vector<TString>;
7447 }
7448 static void *newArray_vectorlETStringgR(Long_t nElements, void *p) {
7449 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString>[nElements] : new vector<TString>[nElements];
7450 }
7451 // Wrapper around operator delete
7452 static void delete_vectorlETStringgR(void *p) {
7453 delete ((vector<TString>*)p);
7454 }
7455 static void deleteArray_vectorlETStringgR(void *p) {
7456 delete [] ((vector<TString>*)p);
7457 }
7458 static void destruct_vectorlETStringgR(void *p) {
7459 typedef vector<TString> current_t;
7460 ((current_t*)p)->~current_t();
7461 }
7462} // end of namespace ROOT for class vector<TString>
7463
7464namespace ROOT {
7465 void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
7466 static void vectorlEdoublegR_Dictionary();
7467 static void *new_vectorlEdoublegR(void *p = 0);
7468 static void *newArray_vectorlEdoublegR(Long_t size, void *p);
7469 static void delete_vectorlEdoublegR(void *p);
7470 static void deleteArray_vectorlEdoublegR(void *p);
7471 static void destruct_vectorlEdoublegR(void *p);
7472
7473 // Function generating the singleton type initializer
7474 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
7475 {
7476 vector<double> *ptr = 0;
7477 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
7478 static ::ROOT::TGenericClassInfo
7479 instance("vector<double>", -2, "vector.dll", 0,
7480 typeid(vector<double>), DefineBehavior(ptr, ptr),
7481 0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
7482 sizeof(vector<double>) );
7483 instance.SetNew(&new_vectorlEdoublegR);
7484 instance.SetNewArray(&newArray_vectorlEdoublegR);
7485 instance.SetDelete(&delete_vectorlEdoublegR);
7486 instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
7487 instance.SetDestructor(&destruct_vectorlEdoublegR);
7488 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
7489 return &instance;
7490 }
7491 // Static variable to force the class initialization
7492 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7493
7494 // Dictionary for non-ClassDef classes
7495 static void vectorlEdoublegR_Dictionary() {
7496 ::ROOT::GenerateInitInstanceLocal((const vector<double>*)0x0)->GetClass();
7497 }
7498
7499} // end of namespace ROOT
7500
7501namespace ROOT {
7502 // Wrappers around operator new
7503 static void *new_vectorlEdoublegR(void *p) {
7504 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
7505 }
7506 static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
7507 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
7508 }
7509 // Wrapper around operator delete
7510 static void delete_vectorlEdoublegR(void *p) {
7511 delete ((vector<double>*)p);
7512 }
7513 static void deleteArray_vectorlEdoublegR(void *p) {
7514 delete [] ((vector<double>*)p);
7515 }
7516 static void destruct_vectorlEdoublegR(void *p) {
7517 typedef vector<double> current_t;
7518 ((current_t*)p)->~current_t();
7519 }
7520} // end of namespace ROOT for class vector<double>
7521
7522namespace ROOT {
7523 void vectorlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7524 static void vectorlEfloatgR_Dictionary();
7525 static void *new_vectorlEfloatgR(void *p = 0);
7526 static void *newArray_vectorlEfloatgR(Long_t size, void *p);
7527 static void delete_vectorlEfloatgR(void *p);
7528 static void deleteArray_vectorlEfloatgR(void *p);
7529 static void destruct_vectorlEfloatgR(void *p);
7530
7531 // Function generating the singleton type initializer
7532 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<float>*)
7533 {
7534 vector<float> *ptr = 0;
7535 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<float>),0);
7536 static ::ROOT::TGenericClassInfo
7537 instance("vector<float>", -2, "vector.dll", 0,
7538 typeid(vector<float>), DefineBehavior(ptr, ptr),
7539 0, &vectorlEfloatgR_Dictionary, isa_proxy, 0,
7540 sizeof(vector<float>) );
7541 instance.SetNew(&new_vectorlEfloatgR);
7542 instance.SetNewArray(&newArray_vectorlEfloatgR);
7543 instance.SetDelete(&delete_vectorlEfloatgR);
7544 instance.SetDeleteArray(&deleteArray_vectorlEfloatgR);
7545 instance.SetDestructor(&destruct_vectorlEfloatgR);
7546 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<float> >()));
7547 return &instance;
7548 }
7549 // Static variable to force the class initialization
7550 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7551
7552 // Dictionary for non-ClassDef classes
7553 static void vectorlEfloatgR_Dictionary() {
7554 ::ROOT::GenerateInitInstanceLocal((const vector<float>*)0x0)->GetClass();
7555 }
7556
7557} // end of namespace ROOT
7558
7559namespace ROOT {
7560 // Wrappers around operator new
7561 static void *new_vectorlEfloatgR(void *p) {
7562 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<float> : new vector<float>;
7563 }
7564 static void *newArray_vectorlEfloatgR(Long_t nElements, void *p) {
7565 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<float>[nElements] : new vector<float>[nElements];
7566 }
7567 // Wrapper around operator delete
7568 static void delete_vectorlEfloatgR(void *p) {
7569 delete ((vector<float>*)p);
7570 }
7571 static void deleteArray_vectorlEfloatgR(void *p) {
7572 delete [] ((vector<float>*)p);
7573 }
7574 static void destruct_vectorlEfloatgR(void *p) {
7575 typedef vector<float> current_t;
7576 ((current_t*)p)->~current_t();
7577 }
7578} // end of namespace ROOT for class vector<float>
7579
7580namespace ROOT {
7581 void vectorlEintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7582 static void vectorlEintgR_Dictionary();
7583 static void *new_vectorlEintgR(void *p = 0);
7584 static void *newArray_vectorlEintgR(Long_t size, void *p);
7585 static void delete_vectorlEintgR(void *p);
7586 static void deleteArray_vectorlEintgR(void *p);
7587 static void destruct_vectorlEintgR(void *p);
7588
7589 // Function generating the singleton type initializer
7590 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<int>*)
7591 {
7592 vector<int> *ptr = 0;
7593 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<int>),0);
7594 static ::ROOT::TGenericClassInfo
7595 instance("vector<int>", -2, "prec_stl/vector", 49,
7596 typeid(vector<int>), DefineBehavior(ptr, ptr),
7597 0, &vectorlEintgR_Dictionary, isa_proxy, 0,
7598 sizeof(vector<int>) );
7599 instance.SetNew(&new_vectorlEintgR);
7600 instance.SetNewArray(&newArray_vectorlEintgR);
7601 instance.SetDelete(&delete_vectorlEintgR);
7602 instance.SetDeleteArray(&deleteArray_vectorlEintgR);
7603 instance.SetDestructor(&destruct_vectorlEintgR);
7604 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<int> >()));
7605 return &instance;
7606 }
7607 // Static variable to force the class initialization
7608 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7609
7610 // Dictionary for non-ClassDef classes
7611 static void vectorlEintgR_Dictionary() {
7612 ::ROOT::GenerateInitInstanceLocal((const vector<int>*)0x0)->GetClass();
7613 }
7614
7615} // end of namespace ROOT
7616
7617namespace ROOT {
7618 // Wrappers around operator new
7619 static void *new_vectorlEintgR(void *p) {
7620 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<int> : new vector<int>;
7621 }
7622 static void *newArray_vectorlEintgR(Long_t nElements, void *p) {
7623 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<int>[nElements] : new vector<int>[nElements];
7624 }
7625 // Wrapper around operator delete
7626 static void delete_vectorlEintgR(void *p) {
7627 delete ((vector<int>*)p);
7628 }
7629 static void deleteArray_vectorlEintgR(void *p) {
7630 delete [] ((vector<int>*)p);
7631 }
7632 static void destruct_vectorlEintgR(void *p) {
7633 typedef vector<int> current_t;
7634 ((current_t*)p)->~current_t();
7635 }
7636} // end of namespace ROOT for class vector<int>
7637
7638namespace ROOT {
7639 void vectorlEpairlEintcOfloatgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7640 static void vectorlEpairlEintcOfloatgRsPgR_Dictionary();
7641 static void *new_vectorlEpairlEintcOfloatgRsPgR(void *p = 0);
7642 static void *newArray_vectorlEpairlEintcOfloatgRsPgR(Long_t size, void *p);
7643 static void delete_vectorlEpairlEintcOfloatgRsPgR(void *p);
7644 static void deleteArray_vectorlEpairlEintcOfloatgRsPgR(void *p);
7645 static void destruct_vectorlEpairlEintcOfloatgRsPgR(void *p);
7646
7647 // Function generating the singleton type initializer
7648 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<pair<int,float> >*)
7649 {
7650 vector<pair<int,float> > *ptr = 0;
7651 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<pair<int,float> >),0);
7652 static ::ROOT::TGenericClassInfo
7653 instance("vector<pair<int,float> >", -2, "prec_stl/vector", 49,
7654 typeid(vector<pair<int,float> >), DefineBehavior(ptr, ptr),
7655 0, &vectorlEpairlEintcOfloatgRsPgR_Dictionary, isa_proxy, 0,
7656 sizeof(vector<pair<int,float> >) );
7657 instance.SetNew(&new_vectorlEpairlEintcOfloatgRsPgR);
7658 instance.SetNewArray(&newArray_vectorlEpairlEintcOfloatgRsPgR);
7659 instance.SetDelete(&delete_vectorlEpairlEintcOfloatgRsPgR);
7660 instance.SetDeleteArray(&deleteArray_vectorlEpairlEintcOfloatgRsPgR);
7661 instance.SetDestructor(&destruct_vectorlEpairlEintcOfloatgRsPgR);
7662 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<pair<int,float> > >()));
7663 return &instance;
7664 }
7665 // Static variable to force the class initialization
7666 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<pair<int,float> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7667
7668 // Dictionary for non-ClassDef classes
7669 static void vectorlEpairlEintcOfloatgRsPgR_Dictionary() {
7670 ::ROOT::GenerateInitInstanceLocal((const vector<pair<int,float> >*)0x0)->GetClass();
7671 }
7672
7673} // end of namespace ROOT
7674
7675namespace ROOT {
7676 // Wrappers around operator new
7677 static void *new_vectorlEpairlEintcOfloatgRsPgR(void *p) {
7678 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<pair<int,float> > : new vector<pair<int,float> >;
7679 }
7680 static void *newArray_vectorlEpairlEintcOfloatgRsPgR(Long_t nElements, void *p) {
7681 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<pair<int,float> >[nElements] : new vector<pair<int,float> >[nElements];
7682 }
7683 // Wrapper around operator delete
7684 static void delete_vectorlEpairlEintcOfloatgRsPgR(void *p) {
7685 delete ((vector<pair<int,float> >*)p);
7686 }
7687 static void deleteArray_vectorlEpairlEintcOfloatgRsPgR(void *p) {
7688 delete [] ((vector<pair<int,float> >*)p);
7689 }
7690 static void destruct_vectorlEpairlEintcOfloatgRsPgR(void *p) {
7691 typedef vector<pair<int,float> > current_t;
7692 ((current_t*)p)->~current_t();
7693 }
7694} // end of namespace ROOT for class vector<pair<int,float> >
7695
7696namespace ROOT {
7697 void vectorlEstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7698 static void vectorlEstringgR_Dictionary();
7699 static void *new_vectorlEstringgR(void *p = 0);
7700 static void *newArray_vectorlEstringgR(Long_t size, void *p);
7701 static void delete_vectorlEstringgR(void *p);
7702 static void deleteArray_vectorlEstringgR(void *p);
7703 static void destruct_vectorlEstringgR(void *p);
7704
7705 // Function generating the singleton type initializer
7706 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
7707 {
7708 vector<string> *ptr = 0;
7709 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>),0);
7710 static ::ROOT::TGenericClassInfo
7711 instance("vector<string>", -2, "prec_stl/vector", 49,
7712 typeid(vector<string>), DefineBehavior(ptr, ptr),
7713 0, &vectorlEstringgR_Dictionary, isa_proxy, 0,
7714 sizeof(vector<string>) );
7715 instance.SetNew(&new_vectorlEstringgR);
7716 instance.SetNewArray(&newArray_vectorlEstringgR);
7717 instance.SetDelete(&delete_vectorlEstringgR);
7718 instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
7719 instance.SetDestructor(&destruct_vectorlEstringgR);
7720 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));
7721 return &instance;
7722 }
7723 // Static variable to force the class initialization
7724 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7725
7726 // Dictionary for non-ClassDef classes
7727 static void vectorlEstringgR_Dictionary() {
7728 ::ROOT::GenerateInitInstanceLocal((const vector<string>*)0x0)->GetClass();
7729 }
7730
7731} // end of namespace ROOT
7732
7733namespace ROOT {
7734 // Wrappers around operator new
7735 static void *new_vectorlEstringgR(void *p) {
7736 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string> : new vector<string>;
7737 }
7738 static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
7739 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string>[nElements] : new vector<string>[nElements];
7740 }
7741 // Wrapper around operator delete
7742 static void delete_vectorlEstringgR(void *p) {
7743 delete ((vector<string>*)p);
7744 }
7745 static void deleteArray_vectorlEstringgR(void *p) {
7746 delete [] ((vector<string>*)p);
7747 }
7748 static void destruct_vectorlEstringgR(void *p) {
7749 typedef vector<string> current_t;
7750 ((current_t*)p)->~current_t();
7751 }
7752} // end of namespace ROOT for class vector<string>
7753
7754namespace ROOT {
7755 void vectorlEvectorlEdoublegRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7756 static void vectorlEvectorlEdoublegRsPgR_Dictionary();
7757 static void *new_vectorlEvectorlEdoublegRsPgR(void *p = 0);
7758 static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t size, void *p);
7759 static void delete_vectorlEvectorlEdoublegRsPgR(void *p);
7760 static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p);
7761 static void destruct_vectorlEvectorlEdoublegRsPgR(void *p);
7762
7763 // Function generating the singleton type initializer
7764 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<vector<double> >*)
7765 {
7766 vector<vector<double> > *ptr = 0;
7767 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<vector<double> >),0);
7768 static ::ROOT::TGenericClassInfo
7769 instance("vector<vector<double> >", -2, "prec_stl/vector", 49,
7770 typeid(vector<vector<double> >), DefineBehavior(ptr, ptr),
7771 0, &vectorlEvectorlEdoublegRsPgR_Dictionary, isa_proxy, 0,
7772 sizeof(vector<vector<double> >) );
7773 instance.SetNew(&new_vectorlEvectorlEdoublegRsPgR);
7774 instance.SetNewArray(&newArray_vectorlEvectorlEdoublegRsPgR);
7775 instance.SetDelete(&delete_vectorlEvectorlEdoublegRsPgR);
7776 instance.SetDeleteArray(&deleteArray_vectorlEvectorlEdoublegRsPgR);
7777 instance.SetDestructor(&destruct_vectorlEvectorlEdoublegRsPgR);
7778 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<vector<double> > >()));
7779 return &instance;
7780 }
7781 // Static variable to force the class initialization
7782 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<vector<double> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7783
7784 // Dictionary for non-ClassDef classes
7785 static void vectorlEvectorlEdoublegRsPgR_Dictionary() {
7786 ::ROOT::GenerateInitInstanceLocal((const vector<vector<double> >*)0x0)->GetClass();
7787 }
7788
7789} // end of namespace ROOT
7790
7791namespace ROOT {
7792 // Wrappers around operator new
7793 static void *new_vectorlEvectorlEdoublegRsPgR(void *p) {
7794 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<vector<double> > : new vector<vector<double> >;
7795 }
7796 static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t nElements, void *p) {
7797 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<vector<double> >[nElements] : new vector<vector<double> >[nElements];
7798 }
7799 // Wrapper around operator delete
7800 static void delete_vectorlEvectorlEdoublegRsPgR(void *p) {
7801 delete ((vector<vector<double> >*)p);
7802 }
7803 static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p) {
7804 delete [] ((vector<vector<double> >*)p);
7805 }
7806 static void destruct_vectorlEvectorlEdoublegRsPgR(void *p) {
7807 typedef vector<vector<double> > current_t;
7808 ((current_t*)p)->~current_t();
7809 }
7810} // end of namespace ROOT for class vector<vector<double> >
7811
7812/********************************************************
7813* ../RootEventData/RootEventData_rootcint.cxx
7814* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
7815* FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
7816* CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
7817********************************************************/
7818
7819#ifdef G__MEMTEST
7820#undef malloc
7821#undef free
7822#endif
7823
7824#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
7825#pragma GCC diagnostic ignored "-Wstrict-aliasing"
7826#endif
7827
7828extern "C" void G__cpp_reset_tagtableRootEventData_rootcint();
7829
7830extern "C" void G__set_cpp_environmentRootEventData_rootcint() {
7831 G__add_compiledheader("TObject.h");
7832 G__add_compiledheader("TMemberInspector.h");
7833 G__add_compiledheader("../RootEventData/TJobInfo.h");
7834 G__add_compiledheader("../RootEventData/TDigiEvent.h");
7835 G__add_compiledheader("../RootEventData/TRecTrackEvent.h");
7836 G__add_compiledheader("../RootEventData/TMdcDigi.h");
7837 G__add_compiledheader("../RootEventData/TEmcDigi.h");
7838 G__add_compiledheader("../RootEventData/TTofDigi.h");
7839 G__add_compiledheader("../RootEventData/TMucDigi.h");
7840 G__add_compiledheader("../RootEventData/TLumiDigi.h");
7841 G__add_compiledheader("../RootEventData/TDstEvent.h");
7842 G__add_compiledheader("../RootEventData/TEmcTrack.h");
7843 G__add_compiledheader("../RootEventData/TMdcTrack.h");
7844 G__add_compiledheader("../RootEventData/TRecMdcHit.h");
7845 G__add_compiledheader("../RootEventData/TRecMdcTrack.h");
7846 G__add_compiledheader("../RootEventData/TRecMucTrack.h");
7847 G__add_compiledheader("../RootEventData/TTofTrack.h");
7848 G__add_compiledheader("../RootEventData/TMucTrack.h");
7849 G__add_compiledheader("../RootEventData/TExtTrack.h");
7850 G__add_compiledheader("../RootEventData/TRecExtTrack.h");
7851 G__add_compiledheader("../RootEventData/TMdcKalTrack.h");
7852 G__add_compiledheader("../RootEventData/TRecMdcKalTrack.h");
7853 G__add_compiledheader("../RootEventData/TRecMdcKalHelixSeg.h");
7854 G__add_compiledheader("../RootEventData/TMdcDedx.h");
7855 G__add_compiledheader("../RootEventData/TRecMdcDedx.h");
7856 G__add_compiledheader("../RootEventData/TRecMdcDedxHit.h");
7857 G__add_compiledheader("../RootEventData/TMcEvent.h");
7858 G__add_compiledheader("../RootEventData/TEmcMc.h");
7859 G__add_compiledheader("../RootEventData/TMdcMc.h");
7860 G__add_compiledheader("../RootEventData/TTofMc.h");
7861 G__add_compiledheader("../RootEventData/TMucMc.h");
7862 G__add_compiledheader("../RootEventData/TMcParticle.h");
7863 G__add_compiledheader("../RootEventData/TRecEmcHit.h");
7864 G__add_compiledheader("../RootEventData/TRecEmcCluster.h");
7865 G__add_compiledheader("../RootEventData/TRecEmcShower.h");
7866 G__add_compiledheader("../RootEventData/TRecMucTrack.h");
7867 G__add_compiledheader("../RootEventData/TRecEvTime.h");
7868 G__add_compiledheader("../RootEventData/TRecZddChannel.h");
7869 G__add_compiledheader("../RootEventData/TEvtHeader.h");
7870 G__add_compiledheader("../RootEventData/TEvtNavigator.h");
7871 G__add_compiledheader("../RootEventData/TTrigEvent.h");
7872 G__add_compiledheader("../RootEventData/TTrigData.h");
7873 G__add_compiledheader("../RootEventData/THltEvent.h");
7874 G__add_compiledheader("../RootEventData/THltRaw.h");
7875 G__add_compiledheader("../RootEventData/THltInf.h");
7876 G__add_compiledheader("../RootEventData/TDstHltInf.h");
7877 G__add_compiledheader("../RootEventData/TDisTrack.h");
7878 G__add_compiledheader("../RootEventData/TEvtRecObject.h");
7879 G__add_compiledheader("../RootEventData/TEvtRecEvent.h");
7880 G__add_compiledheader("../RootEventData/TEvtRecTrack.h");
7881 G__add_compiledheader("../RootEventData/TMcHitEvent.h");
7882 G__add_compiledheader("../RootEventData/TMcHitTof.h");
7883 G__add_compiledheader("../RootEventData/TMcHitMdc.h");
7884 G__add_compiledheader("../RootEventData/TMcDigiEmc.h");
7885 G__add_compiledheader("../RootEventData/TEvtRecPrimaryVertex.h");
7886 G__add_compiledheader("../RootEventData/TEvtRecVeeVertex.h");
7887 G__add_compiledheader("../RootEventData/TEvtRecDTag.h");
7888 G__add_compiledheader("../RootEventData/TEvtRecPi0.h");
7889 G__add_compiledheader("../RootEventData/TBossFullEvent.h");
7890 G__cpp_reset_tagtableRootEventData_rootcint();
7891}
7892#include <new>
7893extern "C" int G__cpp_dllrevRootEventData_rootcint() { return(30051515); }
7894
7895/*********************************************************
7896* Member function Interface Method
7897*********************************************************/
7898
7899/* TJobInfo */
7900static int G__RootEventData_rootcint_168_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7901{
7902 TJobInfo* p = NULL;
7903 char* gvp = (char*) G__getgvp();
7904 int n = G__getaryconstruct();
7905 if (n) {
7906 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7907 p = new TJobInfo[n];
7908 } else {
7909 p = new((void*) gvp) TJobInfo[n];
7910 }
7911 } else {
7912 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7913 p = new TJobInfo;
7914 } else {
7915 p = new((void*) gvp) TJobInfo;
7916 }
7917 }
7918 result7->obj.i = (long) p;
7919 result7->ref = (long) p;
7920 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo));
7921 return(1 || funcname || hash || result7 || libp) ;
7922}
7923
7924static int G__RootEventData_rootcint_168_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7925{
7926 {
7927 const string* pobj;
7928 const string xobj = ((const TJobInfo*) G__getstructoffset())->getBossVer();
7929 pobj = new string(xobj);
7930 result7->obj.i = (long) ((void*) pobj);
7931 result7->ref = result7->obj.i;
7932 G__store_tempobject(*result7);
7933 }
7934 return(1 || funcname || hash || result7 || libp) ;
7935}
7936
7937static int G__RootEventData_rootcint_168_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7938{
7939 {
7940 const vector<string>* pobj;
7941 const vector<string> xobj = ((const TJobInfo*) G__getstructoffset())->getJobOptions();
7942 pobj = new vector<string>(xobj);
7943 result7->obj.i = (long) ((void*) pobj);
7944 result7->ref = result7->obj.i;
7945 G__store_tempobject(*result7);
7946 }
7947 return(1 || funcname || hash || result7 || libp) ;
7948}
7949
7950static int G__RootEventData_rootcint_168_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7951{
7952 {
7953 const string* pobj;
7954 const string xobj = ((const TJobInfo*) G__getstructoffset())->getDecayOptions();
7955 pobj = new string(xobj);
7956 result7->obj.i = (long) ((void*) pobj);
7957 result7->ref = result7->obj.i;
7958 G__store_tempobject(*result7);
7959 }
7960 return(1 || funcname || hash || result7 || libp) ;
7961}
7962
7963static int G__RootEventData_rootcint_168_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7964{
7965 {
7966 const vector<int>* pobj;
7967 const vector<int> xobj = ((const TJobInfo*) G__getstructoffset())->getTotEvtNo();
7968 pobj = new vector<int>(xobj);
7969 result7->obj.i = (long) ((void*) pobj);
7970 result7->ref = result7->obj.i;
7971 G__store_tempobject(*result7);
7972 }
7973 return(1 || funcname || hash || result7 || libp) ;
7974}
7975
7976static int G__RootEventData_rootcint_168_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7977{
7978 ((TJobInfo*) G__getstructoffset())->setBossVer(*((string*) G__int(libp->para[0])));
7979 G__setnull(result7);
7980 return(1 || funcname || hash || result7 || libp) ;
7981}
7982
7983static int G__RootEventData_rootcint_168_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7984{
7985 ((TJobInfo*) G__getstructoffset())->addJobOptions(*((string*) G__int(libp->para[0])));
7986 G__setnull(result7);
7987 return(1 || funcname || hash || result7 || libp) ;
7988}
7989
7990static int G__RootEventData_rootcint_168_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7991{
7992 ((TJobInfo*) G__getstructoffset())->setJobOptions(*((vector<string>*) G__int(libp->para[0])));
7993 G__setnull(result7);
7994 return(1 || funcname || hash || result7 || libp) ;
7995}
7996
7997static int G__RootEventData_rootcint_168_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7998{
7999 ((TJobInfo*) G__getstructoffset())->setDecayOptions(*((string*) G__int(libp->para[0])));
8000 G__setnull(result7);
8001 return(1 || funcname || hash || result7 || libp) ;
8002}
8003
8004static int G__RootEventData_rootcint_168_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8005{
8006 ((TJobInfo*) G__getstructoffset())->setTotEvtNo(*((vector<int>*) G__int(libp->para[0])));
8007 G__setnull(result7);
8008 return(1 || funcname || hash || result7 || libp) ;
8009}
8010
8011static int G__RootEventData_rootcint_168_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8012{
8013 G__letint(result7, 85, (long) TJobInfo::Class());
8014 return(1 || funcname || hash || result7 || libp) ;
8015}
8016
8017static int G__RootEventData_rootcint_168_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8018{
8019 G__letint(result7, 67, (long) TJobInfo::Class_Name());
8020 return(1 || funcname || hash || result7 || libp) ;
8021}
8022
8023static int G__RootEventData_rootcint_168_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8024{
8025 G__letint(result7, 115, (long) TJobInfo::Class_Version());
8026 return(1 || funcname || hash || result7 || libp) ;
8027}
8028
8029static int G__RootEventData_rootcint_168_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8030{
8031 TJobInfo::Dictionary();
8032 G__setnull(result7);
8033 return(1 || funcname || hash || result7 || libp) ;
8034}
8035
8036static int G__RootEventData_rootcint_168_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8037{
8038 ((TJobInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8039 G__setnull(result7);
8040 return(1 || funcname || hash || result7 || libp) ;
8041}
8042
8043static int G__RootEventData_rootcint_168_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8044{
8045 G__letint(result7, 67, (long) TJobInfo::DeclFileName());
8046 return(1 || funcname || hash || result7 || libp) ;
8047}
8048
8049static int G__RootEventData_rootcint_168_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8050{
8051 G__letint(result7, 105, (long) TJobInfo::ImplFileLine());
8052 return(1 || funcname || hash || result7 || libp) ;
8053}
8054
8055static int G__RootEventData_rootcint_168_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8056{
8057 G__letint(result7, 67, (long) TJobInfo::ImplFileName());
8058 return(1 || funcname || hash || result7 || libp) ;
8059}
8060
8061static int G__RootEventData_rootcint_168_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8062{
8063 G__letint(result7, 105, (long) TJobInfo::DeclFileLine());
8064 return(1 || funcname || hash || result7 || libp) ;
8065}
8066
8067// automatic copy constructor
8068static int G__RootEventData_rootcint_168_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8069
8070{
8071 TJobInfo* p;
8072 void* tmp = (void*) G__int(libp->para[0]);
8073 p = new TJobInfo(*(TJobInfo*) tmp);
8074 result7->obj.i = (long) p;
8075 result7->ref = (long) p;
8076 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo));
8077 return(1 || funcname || hash || result7 || libp) ;
8078}
8079
8080// automatic destructor
8081typedef TJobInfo G__TTJobInfo;
8082static int G__RootEventData_rootcint_168_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8083{
8084 char* gvp = (char*) G__getgvp();
8085 long soff = G__getstructoffset();
8086 int n = G__getaryconstruct();
8087 //
8088 //has_a_delete: 1
8089 //has_own_delete1arg: 0
8090 //has_own_delete2arg: 0
8091 //
8092 if (!soff) {
8093 return(1);
8094 }
8095 if (n) {
8096 if (gvp == (char*)G__PVOID) {
8097 delete[] (TJobInfo*) soff;
8098 } else {
8099 G__setgvp((long) G__PVOID);
8100 for (int i = n - 1; i >= 0; --i) {
8101 ((TJobInfo*) (soff+(sizeof(TJobInfo)*i)))->~G__TTJobInfo();
8102 }
8103 G__setgvp((long)gvp);
8104 }
8105 } else {
8106 if (gvp == (char*)G__PVOID) {
8107 delete (TJobInfo*) soff;
8108 } else {
8109 G__setgvp((long) G__PVOID);
8110 ((TJobInfo*) (soff))->~G__TTJobInfo();
8111 G__setgvp((long)gvp);
8112 }
8113 }
8114 G__setnull(result7);
8115 return(1 || funcname || hash || result7 || libp) ;
8116}
8117
8118// automatic assignment operator
8119static int G__RootEventData_rootcint_168_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8120{
8121 TJobInfo* dest = (TJobInfo*) G__getstructoffset();
8122 *dest = *(TJobInfo*) libp->para[0].ref;
8123 const TJobInfo& obj = *dest;
8124 result7->ref = (long) (&obj);
8125 result7->obj.i = (long) (&obj);
8126 return(1 || funcname || hash || result7 || libp) ;
8127}
8128
8129
8130/* TRawData */
8131static int G__RootEventData_rootcint_200_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8132{
8133 TRawData* p = NULL;
8134 char* gvp = (char*) G__getgvp();
8135 int n = G__getaryconstruct();
8136 if (n) {
8137 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8138 p = new TRawData[n];
8139 } else {
8140 p = new((void*) gvp) TRawData[n];
8141 }
8142 } else {
8143 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8144 p = new TRawData;
8145 } else {
8146 p = new((void*) gvp) TRawData;
8147 }
8148 }
8149 result7->obj.i = (long) p;
8150 result7->ref = (long) p;
8151 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData));
8152 return(1 || funcname || hash || result7 || libp) ;
8153}
8154
8155static int G__RootEventData_rootcint_200_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8156{
8157 switch (libp->paran) {
8158 case 3:
8159 ((TRawData*) G__getstructoffset())->initialize((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
8160, (UInt_t) G__int(libp->para[2]));
8161 G__setnull(result7);
8162 break;
8163 case 2:
8164 ((TRawData*) G__getstructoffset())->initialize((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
8165 G__setnull(result7);
8166 break;
8167 case 1:
8168 ((TRawData*) G__getstructoffset())->initialize((UInt_t) G__int(libp->para[0]));
8169 G__setnull(result7);
8170 break;
8171 }
8172 return(1 || funcname || hash || result7 || libp) ;
8173}
8174
8175static int G__RootEventData_rootcint_200_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8176{
8177 ((TRawData*) G__getstructoffset())->setTrackIndex((const int) G__int(libp->para[0]));
8178 G__setnull(result7);
8179 return(1 || funcname || hash || result7 || libp) ;
8180}
8181
8182static int G__RootEventData_rootcint_200_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8183{
8184 G__letint(result7, 104, (long) ((const TRawData*) G__getstructoffset())->getIntId());
8185 return(1 || funcname || hash || result7 || libp) ;
8186}
8187
8188static int G__RootEventData_rootcint_200_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8189{
8190 G__letint(result7, 104, (long) ((const TRawData*) G__getstructoffset())->getTimeChannel());
8191 return(1 || funcname || hash || result7 || libp) ;
8192}
8193
8194static int G__RootEventData_rootcint_200_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8195{
8196 G__letint(result7, 104, (long) ((const TRawData*) G__getstructoffset())->getChargeChannel());
8197 return(1 || funcname || hash || result7 || libp) ;
8198}
8199
8200static int G__RootEventData_rootcint_200_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8201{
8202 G__letint(result7, 105, (long) ((const TRawData*) G__getstructoffset())->getTrackIndex());
8203 return(1 || funcname || hash || result7 || libp) ;
8204}
8205
8206static int G__RootEventData_rootcint_200_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8207{
8208 G__letint(result7, 85, (long) TRawData::Class());
8209 return(1 || funcname || hash || result7 || libp) ;
8210}
8211
8212static int G__RootEventData_rootcint_200_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8213{
8214 G__letint(result7, 67, (long) TRawData::Class_Name());
8215 return(1 || funcname || hash || result7 || libp) ;
8216}
8217
8218static int G__RootEventData_rootcint_200_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8219{
8220 G__letint(result7, 115, (long) TRawData::Class_Version());
8221 return(1 || funcname || hash || result7 || libp) ;
8222}
8223
8224static int G__RootEventData_rootcint_200_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8225{
8226 TRawData::Dictionary();
8227 G__setnull(result7);
8228 return(1 || funcname || hash || result7 || libp) ;
8229}
8230
8231static int G__RootEventData_rootcint_200_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8232{
8233 ((TRawData*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8234 G__setnull(result7);
8235 return(1 || funcname || hash || result7 || libp) ;
8236}
8237
8238static int G__RootEventData_rootcint_200_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8239{
8240 G__letint(result7, 67, (long) TRawData::DeclFileName());
8241 return(1 || funcname || hash || result7 || libp) ;
8242}
8243
8244static int G__RootEventData_rootcint_200_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8245{
8246 G__letint(result7, 105, (long) TRawData::ImplFileLine());
8247 return(1 || funcname || hash || result7 || libp) ;
8248}
8249
8250static int G__RootEventData_rootcint_200_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8251{
8252 G__letint(result7, 67, (long) TRawData::ImplFileName());
8253 return(1 || funcname || hash || result7 || libp) ;
8254}
8255
8256static int G__RootEventData_rootcint_200_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8257{
8258 G__letint(result7, 105, (long) TRawData::DeclFileLine());
8259 return(1 || funcname || hash || result7 || libp) ;
8260}
8261
8262// automatic copy constructor
8263static int G__RootEventData_rootcint_200_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8264
8265{
8266 TRawData* p;
8267 void* tmp = (void*) G__int(libp->para[0]);
8268 p = new TRawData(*(TRawData*) tmp);
8269 result7->obj.i = (long) p;
8270 result7->ref = (long) p;
8271 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData));
8272 return(1 || funcname || hash || result7 || libp) ;
8273}
8274
8275// automatic destructor
8276typedef TRawData G__TTRawData;
8277static int G__RootEventData_rootcint_200_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8278{
8279 char* gvp = (char*) G__getgvp();
8280 long soff = G__getstructoffset();
8281 int n = G__getaryconstruct();
8282 //
8283 //has_a_delete: 1
8284 //has_own_delete1arg: 0
8285 //has_own_delete2arg: 0
8286 //
8287 if (!soff) {
8288 return(1);
8289 }
8290 if (n) {
8291 if (gvp == (char*)G__PVOID) {
8292 delete[] (TRawData*) soff;
8293 } else {
8294 G__setgvp((long) G__PVOID);
8295 for (int i = n - 1; i >= 0; --i) {
8296 ((TRawData*) (soff+(sizeof(TRawData)*i)))->~G__TTRawData();
8297 }
8298 G__setgvp((long)gvp);
8299 }
8300 } else {
8301 if (gvp == (char*)G__PVOID) {
8302 delete (TRawData*) soff;
8303 } else {
8304 G__setgvp((long) G__PVOID);
8305 ((TRawData*) (soff))->~G__TTRawData();
8306 G__setgvp((long)gvp);
8307 }
8308 }
8309 G__setnull(result7);
8310 return(1 || funcname || hash || result7 || libp) ;
8311}
8312
8313// automatic assignment operator
8314static int G__RootEventData_rootcint_200_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8315{
8316 TRawData* dest = (TRawData*) G__getstructoffset();
8317 *dest = *(TRawData*) libp->para[0].ref;
8318 const TRawData& obj = *dest;
8319 result7->ref = (long) (&obj);
8320 result7->obj.i = (long) (&obj);
8321 return(1 || funcname || hash || result7 || libp) ;
8322}
8323
8324
8325/* TMdcDigi */
8326static int G__RootEventData_rootcint_201_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8327{
8328 TMdcDigi* p = NULL;
8329 char* gvp = (char*) G__getgvp();
8330 int n = G__getaryconstruct();
8331 if (n) {
8332 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8333 p = new TMdcDigi[n];
8334 } else {
8335 p = new((void*) gvp) TMdcDigi[n];
8336 }
8337 } else {
8338 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8339 p = new TMdcDigi;
8340 } else {
8341 p = new((void*) gvp) TMdcDigi;
8342 }
8343 }
8344 result7->obj.i = (long) p;
8345 result7->ref = (long) p;
8346 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi));
8347 return(1 || funcname || hash || result7 || libp) ;
8348}
8349
8350static int G__RootEventData_rootcint_201_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8351{
8352 ((TMdcDigi*) G__getstructoffset())->setOverflow((const UInt_t) G__int(libp->para[0]));
8353 G__setnull(result7);
8354 return(1 || funcname || hash || result7 || libp) ;
8355}
8356
8357static int G__RootEventData_rootcint_201_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8358{
8359 G__letint(result7, 104, (long) ((const TMdcDigi*) G__getstructoffset())->getOverflow());
8360 return(1 || funcname || hash || result7 || libp) ;
8361}
8362
8363static int G__RootEventData_rootcint_201_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8364{
8365 G__letint(result7, 85, (long) TMdcDigi::Class());
8366 return(1 || funcname || hash || result7 || libp) ;
8367}
8368
8369static int G__RootEventData_rootcint_201_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8370{
8371 G__letint(result7, 67, (long) TMdcDigi::Class_Name());
8372 return(1 || funcname || hash || result7 || libp) ;
8373}
8374
8375static int G__RootEventData_rootcint_201_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8376{
8377 G__letint(result7, 115, (long) TMdcDigi::Class_Version());
8378 return(1 || funcname || hash || result7 || libp) ;
8379}
8380
8381static int G__RootEventData_rootcint_201_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8382{
8383 TMdcDigi::Dictionary();
8384 G__setnull(result7);
8385 return(1 || funcname || hash || result7 || libp) ;
8386}
8387
8388static int G__RootEventData_rootcint_201_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8389{
8390 ((TMdcDigi*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8391 G__setnull(result7);
8392 return(1 || funcname || hash || result7 || libp) ;
8393}
8394
8395static int G__RootEventData_rootcint_201_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8396{
8397 G__letint(result7, 67, (long) TMdcDigi::DeclFileName());
8398 return(1 || funcname || hash || result7 || libp) ;
8399}
8400
8401static int G__RootEventData_rootcint_201_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8402{
8403 G__letint(result7, 105, (long) TMdcDigi::ImplFileLine());
8404 return(1 || funcname || hash || result7 || libp) ;
8405}
8406
8407static int G__RootEventData_rootcint_201_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8408{
8409 G__letint(result7, 67, (long) TMdcDigi::ImplFileName());
8410 return(1 || funcname || hash || result7 || libp) ;
8411}
8412
8413static int G__RootEventData_rootcint_201_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8414{
8415 G__letint(result7, 105, (long) TMdcDigi::DeclFileLine());
8416 return(1 || funcname || hash || result7 || libp) ;
8417}
8418
8419// automatic copy constructor
8420static int G__RootEventData_rootcint_201_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8421
8422{
8423 TMdcDigi* p;
8424 void* tmp = (void*) G__int(libp->para[0]);
8425 p = new TMdcDigi(*(TMdcDigi*) tmp);
8426 result7->obj.i = (long) p;
8427 result7->ref = (long) p;
8428 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi));
8429 return(1 || funcname || hash || result7 || libp) ;
8430}
8431
8432// automatic destructor
8433typedef TMdcDigi G__TTMdcDigi;
8434static int G__RootEventData_rootcint_201_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8435{
8436 char* gvp = (char*) G__getgvp();
8437 long soff = G__getstructoffset();
8438 int n = G__getaryconstruct();
8439 //
8440 //has_a_delete: 1
8441 //has_own_delete1arg: 0
8442 //has_own_delete2arg: 0
8443 //
8444 if (!soff) {
8445 return(1);
8446 }
8447 if (n) {
8448 if (gvp == (char*)G__PVOID) {
8449 delete[] (TMdcDigi*) soff;
8450 } else {
8451 G__setgvp((long) G__PVOID);
8452 for (int i = n - 1; i >= 0; --i) {
8453 ((TMdcDigi*) (soff+(sizeof(TMdcDigi)*i)))->~G__TTMdcDigi();
8454 }
8455 G__setgvp((long)gvp);
8456 }
8457 } else {
8458 if (gvp == (char*)G__PVOID) {
8459 delete (TMdcDigi*) soff;
8460 } else {
8461 G__setgvp((long) G__PVOID);
8462 ((TMdcDigi*) (soff))->~G__TTMdcDigi();
8463 G__setgvp((long)gvp);
8464 }
8465 }
8466 G__setnull(result7);
8467 return(1 || funcname || hash || result7 || libp) ;
8468}
8469
8470// automatic assignment operator
8471static int G__RootEventData_rootcint_201_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8472{
8473 TMdcDigi* dest = (TMdcDigi*) G__getstructoffset();
8474 *dest = *(TMdcDigi*) libp->para[0].ref;
8475 const TMdcDigi& obj = *dest;
8476 result7->ref = (long) (&obj);
8477 result7->obj.i = (long) (&obj);
8478 return(1 || funcname || hash || result7 || libp) ;
8479}
8480
8481
8482/* TEmcDigi */
8483static int G__RootEventData_rootcint_202_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8484{
8485 TEmcDigi* p = NULL;
8486 char* gvp = (char*) G__getgvp();
8487 int n = G__getaryconstruct();
8488 if (n) {
8489 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8490 p = new TEmcDigi[n];
8491 } else {
8492 p = new((void*) gvp) TEmcDigi[n];
8493 }
8494 } else {
8495 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8496 p = new TEmcDigi;
8497 } else {
8498 p = new((void*) gvp) TEmcDigi;
8499 }
8500 }
8501 result7->obj.i = (long) p;
8502 result7->ref = (long) p;
8503 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi));
8504 return(1 || funcname || hash || result7 || libp) ;
8505}
8506
8507static int G__RootEventData_rootcint_202_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8508{
8509 ((TEmcDigi*) G__getstructoffset())->setMeasure((const UInt_t) G__int(libp->para[0]));
8510 G__setnull(result7);
8511 return(1 || funcname || hash || result7 || libp) ;
8512}
8513
8514static int G__RootEventData_rootcint_202_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8515{
8516 G__letint(result7, 104, (long) ((const TEmcDigi*) G__getstructoffset())->getMeasure());
8517 return(1 || funcname || hash || result7 || libp) ;
8518}
8519
8520static int G__RootEventData_rootcint_202_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8521{
8522 G__letint(result7, 85, (long) TEmcDigi::Class());
8523 return(1 || funcname || hash || result7 || libp) ;
8524}
8525
8526static int G__RootEventData_rootcint_202_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8527{
8528 G__letint(result7, 67, (long) TEmcDigi::Class_Name());
8529 return(1 || funcname || hash || result7 || libp) ;
8530}
8531
8532static int G__RootEventData_rootcint_202_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8533{
8534 G__letint(result7, 115, (long) TEmcDigi::Class_Version());
8535 return(1 || funcname || hash || result7 || libp) ;
8536}
8537
8538static int G__RootEventData_rootcint_202_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8539{
8540 TEmcDigi::Dictionary();
8541 G__setnull(result7);
8542 return(1 || funcname || hash || result7 || libp) ;
8543}
8544
8545static int G__RootEventData_rootcint_202_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8546{
8547 ((TEmcDigi*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8548 G__setnull(result7);
8549 return(1 || funcname || hash || result7 || libp) ;
8550}
8551
8552static int G__RootEventData_rootcint_202_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8553{
8554 G__letint(result7, 67, (long) TEmcDigi::DeclFileName());
8555 return(1 || funcname || hash || result7 || libp) ;
8556}
8557
8558static int G__RootEventData_rootcint_202_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8559{
8560 G__letint(result7, 105, (long) TEmcDigi::ImplFileLine());
8561 return(1 || funcname || hash || result7 || libp) ;
8562}
8563
8564static int G__RootEventData_rootcint_202_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8565{
8566 G__letint(result7, 67, (long) TEmcDigi::ImplFileName());
8567 return(1 || funcname || hash || result7 || libp) ;
8568}
8569
8570static int G__RootEventData_rootcint_202_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8571{
8572 G__letint(result7, 105, (long) TEmcDigi::DeclFileLine());
8573 return(1 || funcname || hash || result7 || libp) ;
8574}
8575
8576// automatic copy constructor
8577static int G__RootEventData_rootcint_202_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8578
8579{
8580 TEmcDigi* p;
8581 void* tmp = (void*) G__int(libp->para[0]);
8582 p = new TEmcDigi(*(TEmcDigi*) tmp);
8583 result7->obj.i = (long) p;
8584 result7->ref = (long) p;
8585 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi));
8586 return(1 || funcname || hash || result7 || libp) ;
8587}
8588
8589// automatic destructor
8590typedef TEmcDigi G__TTEmcDigi;
8591static int G__RootEventData_rootcint_202_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8592{
8593 char* gvp = (char*) G__getgvp();
8594 long soff = G__getstructoffset();
8595 int n = G__getaryconstruct();
8596 //
8597 //has_a_delete: 1
8598 //has_own_delete1arg: 0
8599 //has_own_delete2arg: 0
8600 //
8601 if (!soff) {
8602 return(1);
8603 }
8604 if (n) {
8605 if (gvp == (char*)G__PVOID) {
8606 delete[] (TEmcDigi*) soff;
8607 } else {
8608 G__setgvp((long) G__PVOID);
8609 for (int i = n - 1; i >= 0; --i) {
8610 ((TEmcDigi*) (soff+(sizeof(TEmcDigi)*i)))->~G__TTEmcDigi();
8611 }
8612 G__setgvp((long)gvp);
8613 }
8614 } else {
8615 if (gvp == (char*)G__PVOID) {
8616 delete (TEmcDigi*) soff;
8617 } else {
8618 G__setgvp((long) G__PVOID);
8619 ((TEmcDigi*) (soff))->~G__TTEmcDigi();
8620 G__setgvp((long)gvp);
8621 }
8622 }
8623 G__setnull(result7);
8624 return(1 || funcname || hash || result7 || libp) ;
8625}
8626
8627// automatic assignment operator
8628static int G__RootEventData_rootcint_202_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8629{
8630 TEmcDigi* dest = (TEmcDigi*) G__getstructoffset();
8631 *dest = *(TEmcDigi*) libp->para[0].ref;
8632 const TEmcDigi& obj = *dest;
8633 result7->ref = (long) (&obj);
8634 result7->obj.i = (long) (&obj);
8635 return(1 || funcname || hash || result7 || libp) ;
8636}
8637
8638
8639/* TTofDigi */
8640static int G__RootEventData_rootcint_203_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8641{
8642 TTofDigi* p = NULL;
8643 char* gvp = (char*) G__getgvp();
8644 int n = G__getaryconstruct();
8645 if (n) {
8646 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8647 p = new TTofDigi[n];
8648 } else {
8649 p = new((void*) gvp) TTofDigi[n];
8650 }
8651 } else {
8652 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8653 p = new TTofDigi;
8654 } else {
8655 p = new((void*) gvp) TTofDigi;
8656 }
8657 }
8658 result7->obj.i = (long) p;
8659 result7->ref = (long) p;
8660 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi));
8661 return(1 || funcname || hash || result7 || libp) ;
8662}
8663
8664static int G__RootEventData_rootcint_203_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8665{
8666 ((TTofDigi*) G__getstructoffset())->setOverflow((const UInt_t) G__int(libp->para[0]));
8667 G__setnull(result7);
8668 return(1 || funcname || hash || result7 || libp) ;
8669}
8670
8671static int G__RootEventData_rootcint_203_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8672{
8673 G__letint(result7, 104, (long) ((const TTofDigi*) G__getstructoffset())->getOverflow());
8674 return(1 || funcname || hash || result7 || libp) ;
8675}
8676
8677static int G__RootEventData_rootcint_203_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8678{
8679 G__letint(result7, 85, (long) TTofDigi::Class());
8680 return(1 || funcname || hash || result7 || libp) ;
8681}
8682
8683static int G__RootEventData_rootcint_203_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8684{
8685 G__letint(result7, 67, (long) TTofDigi::Class_Name());
8686 return(1 || funcname || hash || result7 || libp) ;
8687}
8688
8689static int G__RootEventData_rootcint_203_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8690{
8691 G__letint(result7, 115, (long) TTofDigi::Class_Version());
8692 return(1 || funcname || hash || result7 || libp) ;
8693}
8694
8695static int G__RootEventData_rootcint_203_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8696{
8697 TTofDigi::Dictionary();
8698 G__setnull(result7);
8699 return(1 || funcname || hash || result7 || libp) ;
8700}
8701
8702static int G__RootEventData_rootcint_203_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8703{
8704 ((TTofDigi*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8705 G__setnull(result7);
8706 return(1 || funcname || hash || result7 || libp) ;
8707}
8708
8709static int G__RootEventData_rootcint_203_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8710{
8711 G__letint(result7, 67, (long) TTofDigi::DeclFileName());
8712 return(1 || funcname || hash || result7 || libp) ;
8713}
8714
8715static int G__RootEventData_rootcint_203_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8716{
8717 G__letint(result7, 105, (long) TTofDigi::ImplFileLine());
8718 return(1 || funcname || hash || result7 || libp) ;
8719}
8720
8721static int G__RootEventData_rootcint_203_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8722{
8723 G__letint(result7, 67, (long) TTofDigi::ImplFileName());
8724 return(1 || funcname || hash || result7 || libp) ;
8725}
8726
8727static int G__RootEventData_rootcint_203_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8728{
8729 G__letint(result7, 105, (long) TTofDigi::DeclFileLine());
8730 return(1 || funcname || hash || result7 || libp) ;
8731}
8732
8733// automatic copy constructor
8734static int G__RootEventData_rootcint_203_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8735
8736{
8737 TTofDigi* p;
8738 void* tmp = (void*) G__int(libp->para[0]);
8739 p = new TTofDigi(*(TTofDigi*) tmp);
8740 result7->obj.i = (long) p;
8741 result7->ref = (long) p;
8742 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi));
8743 return(1 || funcname || hash || result7 || libp) ;
8744}
8745
8746// automatic destructor
8747typedef TTofDigi G__TTTofDigi;
8748static int G__RootEventData_rootcint_203_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8749{
8750 char* gvp = (char*) G__getgvp();
8751 long soff = G__getstructoffset();
8752 int n = G__getaryconstruct();
8753 //
8754 //has_a_delete: 1
8755 //has_own_delete1arg: 0
8756 //has_own_delete2arg: 0
8757 //
8758 if (!soff) {
8759 return(1);
8760 }
8761 if (n) {
8762 if (gvp == (char*)G__PVOID) {
8763 delete[] (TTofDigi*) soff;
8764 } else {
8765 G__setgvp((long) G__PVOID);
8766 for (int i = n - 1; i >= 0; --i) {
8767 ((TTofDigi*) (soff+(sizeof(TTofDigi)*i)))->~G__TTTofDigi();
8768 }
8769 G__setgvp((long)gvp);
8770 }
8771 } else {
8772 if (gvp == (char*)G__PVOID) {
8773 delete (TTofDigi*) soff;
8774 } else {
8775 G__setgvp((long) G__PVOID);
8776 ((TTofDigi*) (soff))->~G__TTTofDigi();
8777 G__setgvp((long)gvp);
8778 }
8779 }
8780 G__setnull(result7);
8781 return(1 || funcname || hash || result7 || libp) ;
8782}
8783
8784// automatic assignment operator
8785static int G__RootEventData_rootcint_203_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8786{
8787 TTofDigi* dest = (TTofDigi*) G__getstructoffset();
8788 *dest = *(TTofDigi*) libp->para[0].ref;
8789 const TTofDigi& obj = *dest;
8790 result7->ref = (long) (&obj);
8791 result7->obj.i = (long) (&obj);
8792 return(1 || funcname || hash || result7 || libp) ;
8793}
8794
8795
8796/* TMucDigi */
8797static int G__RootEventData_rootcint_204_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8798{
8799 TMucDigi* p = NULL;
8800 char* gvp = (char*) G__getgvp();
8801 int n = G__getaryconstruct();
8802 if (n) {
8803 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8804 p = new TMucDigi[n];
8805 } else {
8806 p = new((void*) gvp) TMucDigi[n];
8807 }
8808 } else {
8809 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8810 p = new TMucDigi;
8811 } else {
8812 p = new((void*) gvp) TMucDigi;
8813 }
8814 }
8815 result7->obj.i = (long) p;
8816 result7->ref = (long) p;
8817 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi));
8818 return(1 || funcname || hash || result7 || libp) ;
8819}
8820
8821static int G__RootEventData_rootcint_204_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8822{
8823 G__letint(result7, 85, (long) TMucDigi::Class());
8824 return(1 || funcname || hash || result7 || libp) ;
8825}
8826
8827static int G__RootEventData_rootcint_204_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8828{
8829 G__letint(result7, 67, (long) TMucDigi::Class_Name());
8830 return(1 || funcname || hash || result7 || libp) ;
8831}
8832
8833static int G__RootEventData_rootcint_204_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8834{
8835 G__letint(result7, 115, (long) TMucDigi::Class_Version());
8836 return(1 || funcname || hash || result7 || libp) ;
8837}
8838
8839static int G__RootEventData_rootcint_204_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8840{
8841 TMucDigi::Dictionary();
8842 G__setnull(result7);
8843 return(1 || funcname || hash || result7 || libp) ;
8844}
8845
8846static int G__RootEventData_rootcint_204_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8847{
8848 ((TMucDigi*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8849 G__setnull(result7);
8850 return(1 || funcname || hash || result7 || libp) ;
8851}
8852
8853static int G__RootEventData_rootcint_204_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8854{
8855 G__letint(result7, 67, (long) TMucDigi::DeclFileName());
8856 return(1 || funcname || hash || result7 || libp) ;
8857}
8858
8859static int G__RootEventData_rootcint_204_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8860{
8861 G__letint(result7, 105, (long) TMucDigi::ImplFileLine());
8862 return(1 || funcname || hash || result7 || libp) ;
8863}
8864
8865static int G__RootEventData_rootcint_204_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8866{
8867 G__letint(result7, 67, (long) TMucDigi::ImplFileName());
8868 return(1 || funcname || hash || result7 || libp) ;
8869}
8870
8871static int G__RootEventData_rootcint_204_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8872{
8873 G__letint(result7, 105, (long) TMucDigi::DeclFileLine());
8874 return(1 || funcname || hash || result7 || libp) ;
8875}
8876
8877// automatic copy constructor
8878static int G__RootEventData_rootcint_204_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8879
8880{
8881 TMucDigi* p;
8882 void* tmp = (void*) G__int(libp->para[0]);
8883 p = new TMucDigi(*(TMucDigi*) tmp);
8884 result7->obj.i = (long) p;
8885 result7->ref = (long) p;
8886 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi));
8887 return(1 || funcname || hash || result7 || libp) ;
8888}
8889
8890// automatic destructor
8891typedef TMucDigi G__TTMucDigi;
8892static int G__RootEventData_rootcint_204_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8893{
8894 char* gvp = (char*) G__getgvp();
8895 long soff = G__getstructoffset();
8896 int n = G__getaryconstruct();
8897 //
8898 //has_a_delete: 1
8899 //has_own_delete1arg: 0
8900 //has_own_delete2arg: 0
8901 //
8902 if (!soff) {
8903 return(1);
8904 }
8905 if (n) {
8906 if (gvp == (char*)G__PVOID) {
8907 delete[] (TMucDigi*) soff;
8908 } else {
8909 G__setgvp((long) G__PVOID);
8910 for (int i = n - 1; i >= 0; --i) {
8911 ((TMucDigi*) (soff+(sizeof(TMucDigi)*i)))->~G__TTMucDigi();
8912 }
8913 G__setgvp((long)gvp);
8914 }
8915 } else {
8916 if (gvp == (char*)G__PVOID) {
8917 delete (TMucDigi*) soff;
8918 } else {
8919 G__setgvp((long) G__PVOID);
8920 ((TMucDigi*) (soff))->~G__TTMucDigi();
8921 G__setgvp((long)gvp);
8922 }
8923 }
8924 G__setnull(result7);
8925 return(1 || funcname || hash || result7 || libp) ;
8926}
8927
8928// automatic assignment operator
8929static int G__RootEventData_rootcint_204_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8930{
8931 TMucDigi* dest = (TMucDigi*) G__getstructoffset();
8932 *dest = *(TMucDigi*) libp->para[0].ref;
8933 const TMucDigi& obj = *dest;
8934 result7->ref = (long) (&obj);
8935 result7->obj.i = (long) (&obj);
8936 return(1 || funcname || hash || result7 || libp) ;
8937}
8938
8939
8940/* TLumiDigi */
8941static int G__RootEventData_rootcint_205_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8942{
8943 TLumiDigi* p = NULL;
8944 char* gvp = (char*) G__getgvp();
8945 int n = G__getaryconstruct();
8946 if (n) {
8947 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8948 p = new TLumiDigi[n];
8949 } else {
8950 p = new((void*) gvp) TLumiDigi[n];
8951 }
8952 } else {
8953 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8954 p = new TLumiDigi;
8955 } else {
8956 p = new((void*) gvp) TLumiDigi;
8957 }
8958 }
8959 result7->obj.i = (long) p;
8960 result7->ref = (long) p;
8961 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi));
8962 return(1 || funcname || hash || result7 || libp) ;
8963}
8964
8965static int G__RootEventData_rootcint_205_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8966{
8967 ((TLumiDigi*) G__getstructoffset())->setOverflow((const UInt_t) G__int(libp->para[0]));
8968 G__setnull(result7);
8969 return(1 || funcname || hash || result7 || libp) ;
8970}
8971
8972static int G__RootEventData_rootcint_205_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8973{
8974 G__letint(result7, 104, (long) ((const TLumiDigi*) G__getstructoffset())->getOverflow());
8975 return(1 || funcname || hash || result7 || libp) ;
8976}
8977
8978static int G__RootEventData_rootcint_205_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8979{
8980 G__letint(result7, 85, (long) TLumiDigi::Class());
8981 return(1 || funcname || hash || result7 || libp) ;
8982}
8983
8984static int G__RootEventData_rootcint_205_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8985{
8986 G__letint(result7, 67, (long) TLumiDigi::Class_Name());
8987 return(1 || funcname || hash || result7 || libp) ;
8988}
8989
8990static int G__RootEventData_rootcint_205_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8991{
8992 G__letint(result7, 115, (long) TLumiDigi::Class_Version());
8993 return(1 || funcname || hash || result7 || libp) ;
8994}
8995
8996static int G__RootEventData_rootcint_205_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8997{
8998 TLumiDigi::Dictionary();
8999 G__setnull(result7);
9000 return(1 || funcname || hash || result7 || libp) ;
9001}
9002
9003static int G__RootEventData_rootcint_205_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9004{
9005 ((TLumiDigi*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
9006 G__setnull(result7);
9007 return(1 || funcname || hash || result7 || libp) ;
9008}
9009
9010static int G__RootEventData_rootcint_205_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9011{
9012 G__letint(result7, 67, (long) TLumiDigi::DeclFileName());
9013 return(1 || funcname || hash || result7 || libp) ;
9014}
9015
9016static int G__RootEventData_rootcint_205_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9017{
9018 G__letint(result7, 105, (long) TLumiDigi::ImplFileLine());
9019 return(1 || funcname || hash || result7 || libp) ;
9020}
9021
9022static int G__RootEventData_rootcint_205_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9023{
9024 G__letint(result7, 67, (long) TLumiDigi::ImplFileName());
9025 return(1 || funcname || hash || result7 || libp) ;
9026}
9027
9028static int G__RootEventData_rootcint_205_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9029{
9030 G__letint(result7, 105, (long) TLumiDigi::DeclFileLine());
9031 return(1 || funcname || hash || result7 || libp) ;
9032}
9033
9034// automatic copy constructor
9035static int G__RootEventData_rootcint_205_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9036
9037{
9038 TLumiDigi* p;
9039 void* tmp = (void*) G__int(libp->para[0]);
9040 p = new TLumiDigi(*(TLumiDigi*) tmp);
9041 result7->obj.i = (long) p;
9042 result7->ref = (long) p;
9043 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi));
9044 return(1 || funcname || hash || result7 || libp) ;
9045}
9046
9047// automatic destructor
9048typedef TLumiDigi G__TTLumiDigi;
9049static int G__RootEventData_rootcint_205_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9050{
9051 char* gvp = (char*) G__getgvp();
9052 long soff = G__getstructoffset();
9053 int n = G__getaryconstruct();
9054 //
9055 //has_a_delete: 1
9056 //has_own_delete1arg: 0
9057 //has_own_delete2arg: 0
9058 //
9059 if (!soff) {
9060 return(1);
9061 }
9062 if (n) {
9063 if (gvp == (char*)G__PVOID) {
9064 delete[] (TLumiDigi*) soff;
9065 } else {
9066 G__setgvp((long) G__PVOID);
9067 for (int i = n - 1; i >= 0; --i) {
9068 ((TLumiDigi*) (soff+(sizeof(TLumiDigi)*i)))->~G__TTLumiDigi();
9069 }
9070 G__setgvp((long)gvp);
9071 }
9072 } else {
9073 if (gvp == (char*)G__PVOID) {
9074 delete (TLumiDigi*) soff;
9075 } else {
9076 G__setgvp((long) G__PVOID);
9077 ((TLumiDigi*) (soff))->~G__TTLumiDigi();
9078 G__setgvp((long)gvp);
9079 }
9080 }
9081 G__setnull(result7);
9082 return(1 || funcname || hash || result7 || libp) ;
9083}
9084
9085// automatic assignment operator
9086static int G__RootEventData_rootcint_205_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9087{
9088 TLumiDigi* dest = (TLumiDigi*) G__getstructoffset();
9089 *dest = *(TLumiDigi*) libp->para[0].ref;
9090 const TLumiDigi& obj = *dest;
9091 result7->ref = (long) (&obj);
9092 result7->obj.i = (long) (&obj);
9093 return(1 || funcname || hash || result7 || libp) ;
9094}
9095
9096
9097/* TDigiEvent */
9098static int G__RootEventData_rootcint_206_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9099{
9100 TDigiEvent* p = NULL;
9101 char* gvp = (char*) G__getgvp();
9102 int n = G__getaryconstruct();
9103 if (n) {
9104 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9105 p = new TDigiEvent[n];
9106 } else {
9107 p = new((void*) gvp) TDigiEvent[n];
9108 }
9109 } else {
9110 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9111 p = new TDigiEvent;
9112 } else {
9113 p = new((void*) gvp) TDigiEvent;
9114 }
9115 }
9116 result7->obj.i = (long) p;
9117 result7->ref = (long) p;
9118 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent));
9119 return(1 || funcname || hash || result7 || libp) ;
9120}
9121
9122static int G__RootEventData_rootcint_206_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9123{
9124 switch (libp->paran) {
9125 case 1:
9126 ((TDigiEvent*) G__getstructoffset())->initialize((Bool_t) G__int(libp->para[0]));
9127 G__setnull(result7);
9128 break;
9129 case 0:
9130 ((TDigiEvent*) G__getstructoffset())->initialize();
9131 G__setnull(result7);
9132 break;
9133 }
9134 return(1 || funcname || hash || result7 || libp) ;
9135}
9136
9137static int G__RootEventData_rootcint_206_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9138{
9139 G__letint(result7, 103, (long) ((TDigiEvent*) G__getstructoffset())->getFromMc());
9140 return(1 || funcname || hash || result7 || libp) ;
9141}
9142
9143static int G__RootEventData_rootcint_206_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9144{
9145 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getMdcDigiCol());
9146 return(1 || funcname || hash || result7 || libp) ;
9147}
9148
9149static int G__RootEventData_rootcint_206_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9150{
9151 ((TDigiEvent*) G__getstructoffset())->addMdcDigi((TMdcDigi*) G__int(libp->para[0]));
9152 G__setnull(result7);
9153 return(1 || funcname || hash || result7 || libp) ;
9154}
9155
9156static int G__RootEventData_rootcint_206_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9157{
9158 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getMdcDigi((Int_t) G__int(libp->para[0])));
9159 return(1 || funcname || hash || result7 || libp) ;
9160}
9161
9162static int G__RootEventData_rootcint_206_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9163{
9164 ((TDigiEvent*) G__getstructoffset())->clearMdcDigiCol();
9165 G__setnull(result7);
9166 return(1 || funcname || hash || result7 || libp) ;
9167}
9168
9169static int G__RootEventData_rootcint_206_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9170{
9171 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getEmcDigiCol());
9172 return(1 || funcname || hash || result7 || libp) ;
9173}
9174
9175static int G__RootEventData_rootcint_206_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9176{
9177 ((TDigiEvent*) G__getstructoffset())->addEmcDigi((TEmcDigi*) G__int(libp->para[0]));
9178 G__setnull(result7);
9179 return(1 || funcname || hash || result7 || libp) ;
9180}
9181
9182static int G__RootEventData_rootcint_206_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9183{
9184 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getEmcDigi((Int_t) G__int(libp->para[0])));
9185 return(1 || funcname || hash || result7 || libp) ;
9186}
9187
9188static int G__RootEventData_rootcint_206_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9189{
9190 ((TDigiEvent*) G__getstructoffset())->clearEmcDigiCol();
9191 G__setnull(result7);
9192 return(1 || funcname || hash || result7 || libp) ;
9193}
9194
9195static int G__RootEventData_rootcint_206_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9196{
9197 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getTofDigiCol());
9198 return(1 || funcname || hash || result7 || libp) ;
9199}
9200
9201static int G__RootEventData_rootcint_206_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9202{
9203 ((TDigiEvent*) G__getstructoffset())->addTofDigi((TTofDigi*) G__int(libp->para[0]));
9204 G__setnull(result7);
9205 return(1 || funcname || hash || result7 || libp) ;
9206}
9207
9208static int G__RootEventData_rootcint_206_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9209{
9210 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getTofDigi((Int_t) G__int(libp->para[0])));
9211 return(1 || funcname || hash || result7 || libp) ;
9212}
9213
9214static int G__RootEventData_rootcint_206_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9215{
9216 ((TDigiEvent*) G__getstructoffset())->clearTofDigiCol();
9217 G__setnull(result7);
9218 return(1 || funcname || hash || result7 || libp) ;
9219}
9220
9221static int G__RootEventData_rootcint_206_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9222{
9223 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getMucDigiCol());
9224 return(1 || funcname || hash || result7 || libp) ;
9225}
9226
9227static int G__RootEventData_rootcint_206_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9228{
9229 ((TDigiEvent*) G__getstructoffset())->addMucDigi((TMucDigi*) G__int(libp->para[0]));
9230 G__setnull(result7);
9231 return(1 || funcname || hash || result7 || libp) ;
9232}
9233
9234static int G__RootEventData_rootcint_206_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9235{
9236 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getMucDigi((Int_t) G__int(libp->para[0])));
9237 return(1 || funcname || hash || result7 || libp) ;
9238}
9239
9240static int G__RootEventData_rootcint_206_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9241{
9242 ((TDigiEvent*) G__getstructoffset())->clearMucDigiCol();
9243 G__setnull(result7);
9244 return(1 || funcname || hash || result7 || libp) ;
9245}
9246
9247static int G__RootEventData_rootcint_206_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9248{
9249 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getLumiDigiCol());
9250 return(1 || funcname || hash || result7 || libp) ;
9251}
9252
9253static int G__RootEventData_rootcint_206_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9254{
9255 ((TDigiEvent*) G__getstructoffset())->addLumiDigi((TLumiDigi*) G__int(libp->para[0]));
9256 G__setnull(result7);
9257 return(1 || funcname || hash || result7 || libp) ;
9258}
9259
9260static int G__RootEventData_rootcint_206_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9261{
9262 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getLumiDigi((Int_t) G__int(libp->para[0])));
9263 return(1 || funcname || hash || result7 || libp) ;
9264}
9265
9266static int G__RootEventData_rootcint_206_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9267{
9268 ((TDigiEvent*) G__getstructoffset())->clearLumiDigiCol();
9269 G__setnull(result7);
9270 return(1 || funcname || hash || result7 || libp) ;
9271}
9272
9273static int G__RootEventData_rootcint_206_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9274{
9275 G__letint(result7, 85, (long) TDigiEvent::Class());
9276 return(1 || funcname || hash || result7 || libp) ;
9277}
9278
9279static int G__RootEventData_rootcint_206_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9280{
9281 G__letint(result7, 67, (long) TDigiEvent::Class_Name());
9282 return(1 || funcname || hash || result7 || libp) ;
9283}
9284
9285static int G__RootEventData_rootcint_206_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9286{
9287 G__letint(result7, 115, (long) TDigiEvent::Class_Version());
9288 return(1 || funcname || hash || result7 || libp) ;
9289}
9290
9291static int G__RootEventData_rootcint_206_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9292{
9293 TDigiEvent::Dictionary();
9294 G__setnull(result7);
9295 return(1 || funcname || hash || result7 || libp) ;
9296}
9297
9298static int G__RootEventData_rootcint_206_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9299{
9300 ((TDigiEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
9301 G__setnull(result7);
9302 return(1 || funcname || hash || result7 || libp) ;
9303}
9304
9305static int G__RootEventData_rootcint_206_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9306{
9307 G__letint(result7, 67, (long) TDigiEvent::DeclFileName());
9308 return(1 || funcname || hash || result7 || libp) ;
9309}
9310
9311static int G__RootEventData_rootcint_206_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9312{
9313 G__letint(result7, 105, (long) TDigiEvent::ImplFileLine());
9314 return(1 || funcname || hash || result7 || libp) ;
9315}
9316
9317static int G__RootEventData_rootcint_206_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9318{
9319 G__letint(result7, 67, (long) TDigiEvent::ImplFileName());
9320 return(1 || funcname || hash || result7 || libp) ;
9321}
9322
9323static int G__RootEventData_rootcint_206_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9324{
9325 G__letint(result7, 105, (long) TDigiEvent::DeclFileLine());
9326 return(1 || funcname || hash || result7 || libp) ;
9327}
9328
9329// automatic copy constructor
9330static int G__RootEventData_rootcint_206_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9331
9332{
9333 TDigiEvent* p;
9334 void* tmp = (void*) G__int(libp->para[0]);
9335 p = new TDigiEvent(*(TDigiEvent*) tmp);
9336 result7->obj.i = (long) p;
9337 result7->ref = (long) p;
9338 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent));
9339 return(1 || funcname || hash || result7 || libp) ;
9340}
9341
9342// automatic destructor
9343typedef TDigiEvent G__TTDigiEvent;
9344static int G__RootEventData_rootcint_206_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9345{
9346 char* gvp = (char*) G__getgvp();
9347 long soff = G__getstructoffset();
9348 int n = G__getaryconstruct();
9349 //
9350 //has_a_delete: 1
9351 //has_own_delete1arg: 0
9352 //has_own_delete2arg: 0
9353 //
9354 if (!soff) {
9355 return(1);
9356 }
9357 if (n) {
9358 if (gvp == (char*)G__PVOID) {
9359 delete[] (TDigiEvent*) soff;
9360 } else {
9361 G__setgvp((long) G__PVOID);
9362 for (int i = n - 1; i >= 0; --i) {
9363 ((TDigiEvent*) (soff+(sizeof(TDigiEvent)*i)))->~G__TTDigiEvent();
9364 }
9365 G__setgvp((long)gvp);
9366 }
9367 } else {
9368 if (gvp == (char*)G__PVOID) {
9369 delete (TDigiEvent*) soff;
9370 } else {
9371 G__setgvp((long) G__PVOID);
9372 ((TDigiEvent*) (soff))->~G__TTDigiEvent();
9373 G__setgvp((long)gvp);
9374 }
9375 }
9376 G__setnull(result7);
9377 return(1 || funcname || hash || result7 || libp) ;
9378}
9379
9380// automatic assignment operator
9381static int G__RootEventData_rootcint_206_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9382{
9383 TDigiEvent* dest = (TDigiEvent*) G__getstructoffset();
9384 *dest = *(TDigiEvent*) libp->para[0].ref;
9385 const TDigiEvent& obj = *dest;
9386 result7->ref = (long) (&obj);
9387 result7->obj.i = (long) (&obj);
9388 return(1 || funcname || hash || result7 || libp) ;
9389}
9390
9391
9392/* TRecMdcTrack */
9393static int G__RootEventData_rootcint_207_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9394{
9395 TRecMdcTrack* p = NULL;
9396 char* gvp = (char*) G__getgvp();
9397 int n = G__getaryconstruct();
9398 if (n) {
9399 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9400 p = new TRecMdcTrack[n];
9401 } else {
9402 p = new((void*) gvp) TRecMdcTrack[n];
9403 }
9404 } else {
9405 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9406 p = new TRecMdcTrack;
9407 } else {
9408 p = new((void*) gvp) TRecMdcTrack;
9409 }
9410 }
9411 result7->obj.i = (long) p;
9412 result7->ref = (long) p;
9413 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack));
9414 return(1 || funcname || hash || result7 || libp) ;
9415}
9416
9417static int G__RootEventData_rootcint_207_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9418{
9419 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->trackId());
9420 return(1 || funcname || hash || result7 || libp) ;
9421}
9422
9423static int G__RootEventData_rootcint_207_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9424{
9425 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->helix((Int_t) G__int(libp->para[0])));
9426 return(1 || funcname || hash || result7 || libp) ;
9427}
9428
9429static int G__RootEventData_rootcint_207_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9430{
9431 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->charge());
9432 return(1 || funcname || hash || result7 || libp) ;
9433}
9434
9435static int G__RootEventData_rootcint_207_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9436{
9437 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->pxy());
9438 return(1 || funcname || hash || result7 || libp) ;
9439}
9440
9441static int G__RootEventData_rootcint_207_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9442{
9443 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->px());
9444 return(1 || funcname || hash || result7 || libp) ;
9445}
9446
9447static int G__RootEventData_rootcint_207_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9448{
9449 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->py());
9450 return(1 || funcname || hash || result7 || libp) ;
9451}
9452
9453static int G__RootEventData_rootcint_207_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9454{
9455 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->pz());
9456 return(1 || funcname || hash || result7 || libp) ;
9457}
9458
9459static int G__RootEventData_rootcint_207_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9460{
9461 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->p());
9462 return(1 || funcname || hash || result7 || libp) ;
9463}
9464
9465static int G__RootEventData_rootcint_207_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9466{
9467 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->theta());
9468 return(1 || funcname || hash || result7 || libp) ;
9469}
9470
9471static int G__RootEventData_rootcint_207_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9472{
9473 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->phi());
9474 return(1 || funcname || hash || result7 || libp) ;
9475}
9476
9477static int G__RootEventData_rootcint_207_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9478{
9479 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->x());
9480 return(1 || funcname || hash || result7 || libp) ;
9481}
9482
9483static int G__RootEventData_rootcint_207_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9484{
9485 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->y());
9486 return(1 || funcname || hash || result7 || libp) ;
9487}
9488
9489static int G__RootEventData_rootcint_207_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9490{
9491 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->z());
9492 return(1 || funcname || hash || result7 || libp) ;
9493}
9494
9495static int G__RootEventData_rootcint_207_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9496{
9497 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->r());
9498 return(1 || funcname || hash || result7 || libp) ;
9499}
9500
9501static int G__RootEventData_rootcint_207_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9502{
9503 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->stat());
9504 return(1 || funcname || hash || result7 || libp) ;
9505}
9506
9507static int G__RootEventData_rootcint_207_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9508{
9509 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->chi2());
9510 return(1 || funcname || hash || result7 || libp) ;
9511}
9512
9513static int G__RootEventData_rootcint_207_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9514{
9515 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->ndof());
9516 return(1 || funcname || hash || result7 || libp) ;
9517}
9518
9519static int G__RootEventData_rootcint_207_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9520{
9521 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->err((Int_t) G__int(libp->para[0])));
9522 return(1 || funcname || hash || result7 || libp) ;
9523}
9524
9525static int G__RootEventData_rootcint_207_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9526{
9527 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->nhits());
9528 return(1 || funcname || hash || result7 || libp) ;
9529}
9530
9531static int G__RootEventData_rootcint_207_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9532{
9533 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->nster());
9534 return(1 || funcname || hash || result7 || libp) ;
9535}
9536
9537static int G__RootEventData_rootcint_207_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9538{
9539 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->nlayer());
9540 return(1 || funcname || hash || result7 || libp) ;
9541}
9542
9543static int G__RootEventData_rootcint_207_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9544{
9545 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->vx0());
9546 return(1 || funcname || hash || result7 || libp) ;
9547}
9548
9549static int G__RootEventData_rootcint_207_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9550{
9551 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->vy0());
9552 return(1 || funcname || hash || result7 || libp) ;
9553}
9554
9555static int G__RootEventData_rootcint_207_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9556{
9557 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->vz0());
9558 return(1 || funcname || hash || result7 || libp) ;
9559}
9560
9561static int G__RootEventData_rootcint_207_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9562{
9563 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->fiTerm());
9564 return(1 || funcname || hash || result7 || libp) ;
9565}
9566
9567static int G__RootEventData_rootcint_207_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9568{
9569 ((TRecMdcTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
9570 G__setnull(result7);
9571 return(1 || funcname || hash || result7 || libp) ;
9572}
9573
9574static int G__RootEventData_rootcint_207_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9575{
9576 ((TRecMdcTrack*) G__getstructoffset())->setHelix((Double_t*) G__int(libp->para[0]));
9577 G__setnull(result7);
9578 return(1 || funcname || hash || result7 || libp) ;
9579}
9580
9581static int G__RootEventData_rootcint_207_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9582{
9583 ((TRecMdcTrack*) G__getstructoffset())->setStat((const Int_t) G__int(libp->para[0]));
9584 G__setnull(result7);
9585 return(1 || funcname || hash || result7 || libp) ;
9586}
9587
9588static int G__RootEventData_rootcint_207_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9589{
9590 ((TRecMdcTrack*) G__getstructoffset())->setChi2((const Double_t) G__double(libp->para[0]));
9591 G__setnull(result7);
9592 return(1 || funcname || hash || result7 || libp) ;
9593}
9594
9595static int G__RootEventData_rootcint_207_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9596{
9597 ((TRecMdcTrack*) G__getstructoffset())->setNdof((const Int_t) G__int(libp->para[0]));
9598 G__setnull(result7);
9599 return(1 || funcname || hash || result7 || libp) ;
9600}
9601
9602static int G__RootEventData_rootcint_207_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9603{
9604 ((TRecMdcTrack*) G__getstructoffset())->setErr((Double_t*) G__int(libp->para[0]));
9605 G__setnull(result7);
9606 return(1 || funcname || hash || result7 || libp) ;
9607}
9608
9609static int G__RootEventData_rootcint_207_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9610{
9611 ((TRecMdcTrack*) G__getstructoffset())->setNhits((const Int_t) G__int(libp->para[0]));
9612 G__setnull(result7);
9613 return(1 || funcname || hash || result7 || libp) ;
9614}
9615
9616static int G__RootEventData_rootcint_207_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9617{
9618 ((TRecMdcTrack*) G__getstructoffset())->setNster((const Int_t) G__int(libp->para[0]));
9619 G__setnull(result7);
9620 return(1 || funcname || hash || result7 || libp) ;
9621}
9622
9623static int G__RootEventData_rootcint_207_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9624{
9625 ((TRecMdcTrack*) G__getstructoffset())->setNlayer((const Int_t) G__int(libp->para[0]));
9626 G__setnull(result7);
9627 return(1 || funcname || hash || result7 || libp) ;
9628}
9629
9630static int G__RootEventData_rootcint_207_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9631{
9632 ((TRecMdcTrack*) G__getstructoffset())->setVX0((Double_t) G__double(libp->para[0]));
9633 G__setnull(result7);
9634 return(1 || funcname || hash || result7 || libp) ;
9635}
9636
9637static int G__RootEventData_rootcint_207_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9638{
9639 ((TRecMdcTrack*) G__getstructoffset())->setVY0((Double_t) G__double(libp->para[0]));
9640 G__setnull(result7);
9641 return(1 || funcname || hash || result7 || libp) ;
9642}
9643
9644static int G__RootEventData_rootcint_207_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9645{
9646 ((TRecMdcTrack*) G__getstructoffset())->setVZ0((Double_t) G__double(libp->para[0]));
9647 G__setnull(result7);
9648 return(1 || funcname || hash || result7 || libp) ;
9649}
9650
9651static int G__RootEventData_rootcint_207_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9652{
9653 ((TRecMdcTrack*) G__getstructoffset())->setFiTerm((Double_t) G__double(libp->para[0]));
9654 G__setnull(result7);
9655 return(1 || funcname || hash || result7 || libp) ;
9656}
9657
9658static int G__RootEventData_rootcint_207_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9659{
9660 ((TRecMdcTrack*) G__getstructoffset())->setTRecMdcTrack((TRecMdcTrack*) G__int(libp->para[0]));
9661 G__setnull(result7);
9662 return(1 || funcname || hash || result7 || libp) ;
9663}
9664
9665static int G__RootEventData_rootcint_207_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9666{
9667 G__letint(result7, 85, (long) TRecMdcTrack::Class());
9668 return(1 || funcname || hash || result7 || libp) ;
9669}
9670
9671static int G__RootEventData_rootcint_207_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9672{
9673 G__letint(result7, 67, (long) TRecMdcTrack::Class_Name());
9674 return(1 || funcname || hash || result7 || libp) ;
9675}
9676
9677static int G__RootEventData_rootcint_207_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9678{
9679 G__letint(result7, 115, (long) TRecMdcTrack::Class_Version());
9680 return(1 || funcname || hash || result7 || libp) ;
9681}
9682
9683static int G__RootEventData_rootcint_207_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9684{
9685 TRecMdcTrack::Dictionary();
9686 G__setnull(result7);
9687 return(1 || funcname || hash || result7 || libp) ;
9688}
9689
9690static int G__RootEventData_rootcint_207_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9691{
9692 ((TRecMdcTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
9693 G__setnull(result7);
9694 return(1 || funcname || hash || result7 || libp) ;
9695}
9696
9697static int G__RootEventData_rootcint_207_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9698{
9699 G__letint(result7, 67, (long) TRecMdcTrack::DeclFileName());
9700 return(1 || funcname || hash || result7 || libp) ;
9701}
9702
9703static int G__RootEventData_rootcint_207_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9704{
9705 G__letint(result7, 105, (long) TRecMdcTrack::ImplFileLine());
9706 return(1 || funcname || hash || result7 || libp) ;
9707}
9708
9709static int G__RootEventData_rootcint_207_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9710{
9711 G__letint(result7, 67, (long) TRecMdcTrack::ImplFileName());
9712 return(1 || funcname || hash || result7 || libp) ;
9713}
9714
9715static int G__RootEventData_rootcint_207_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9716{
9717 G__letint(result7, 105, (long) TRecMdcTrack::DeclFileLine());
9718 return(1 || funcname || hash || result7 || libp) ;
9719}
9720
9721// automatic copy constructor
9722static int G__RootEventData_rootcint_207_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9723
9724{
9725 TRecMdcTrack* p;
9726 void* tmp = (void*) G__int(libp->para[0]);
9727 p = new TRecMdcTrack(*(TRecMdcTrack*) tmp);
9728 result7->obj.i = (long) p;
9729 result7->ref = (long) p;
9730 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack));
9731 return(1 || funcname || hash || result7 || libp) ;
9732}
9733
9734// automatic destructor
9735typedef TRecMdcTrack G__TTRecMdcTrack;
9736static int G__RootEventData_rootcint_207_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9737{
9738 char* gvp = (char*) G__getgvp();
9739 long soff = G__getstructoffset();
9740 int n = G__getaryconstruct();
9741 //
9742 //has_a_delete: 1
9743 //has_own_delete1arg: 0
9744 //has_own_delete2arg: 0
9745 //
9746 if (!soff) {
9747 return(1);
9748 }
9749 if (n) {
9750 if (gvp == (char*)G__PVOID) {
9751 delete[] (TRecMdcTrack*) soff;
9752 } else {
9753 G__setgvp((long) G__PVOID);
9754 for (int i = n - 1; i >= 0; --i) {
9755 ((TRecMdcTrack*) (soff+(sizeof(TRecMdcTrack)*i)))->~G__TTRecMdcTrack();
9756 }
9757 G__setgvp((long)gvp);
9758 }
9759 } else {
9760 if (gvp == (char*)G__PVOID) {
9761 delete (TRecMdcTrack*) soff;
9762 } else {
9763 G__setgvp((long) G__PVOID);
9764 ((TRecMdcTrack*) (soff))->~G__TTRecMdcTrack();
9765 G__setgvp((long)gvp);
9766 }
9767 }
9768 G__setnull(result7);
9769 return(1 || funcname || hash || result7 || libp) ;
9770}
9771
9772// automatic assignment operator
9773static int G__RootEventData_rootcint_207_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9774{
9775 TRecMdcTrack* dest = (TRecMdcTrack*) G__getstructoffset();
9776 *dest = *(TRecMdcTrack*) libp->para[0].ref;
9777 const TRecMdcTrack& obj = *dest;
9778 result7->ref = (long) (&obj);
9779 result7->obj.i = (long) (&obj);
9780 return(1 || funcname || hash || result7 || libp) ;
9781}
9782
9783
9784/* TRecMdcKalTrack */
9785static int G__RootEventData_rootcint_208_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9786{
9787 TRecMdcKalTrack* p = NULL;
9788 char* gvp = (char*) G__getgvp();
9789 int n = G__getaryconstruct();
9790 if (n) {
9791 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9792 p = new TRecMdcKalTrack[n];
9793 } else {
9794 p = new((void*) gvp) TRecMdcKalTrack[n];
9795 }
9796 } else {
9797 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9798 p = new TRecMdcKalTrack;
9799 } else {
9800 p = new((void*) gvp) TRecMdcKalTrack;
9801 }
9802 }
9803 result7->obj.i = (long) p;
9804 result7->ref = (long) p;
9805 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack));
9806 return(1 || funcname || hash || result7 || libp) ;
9807}
9808
9809static int G__RootEventData_rootcint_208_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9810{
9811 G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getTrackId());
9812 return(1 || funcname || hash || result7 || libp) ;
9813}
9814
9815static int G__RootEventData_rootcint_208_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9816{
9817 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getMass((Int_t) G__int(libp->para[0])));
9818 return(1 || funcname || hash || result7 || libp) ;
9819}
9820
9821static int G__RootEventData_rootcint_208_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9822{
9823 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLength((Int_t) G__int(libp->para[0])));
9824 return(1 || funcname || hash || result7 || libp) ;
9825}
9826
9827static int G__RootEventData_rootcint_208_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9828{
9829 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getTof((Int_t) G__int(libp->para[0])));
9830 return(1 || funcname || hash || result7 || libp) ;
9831}
9832
9833static int G__RootEventData_rootcint_208_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9834{
9835 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getfiTerm((Int_t) G__int(libp->para[0])));
9836 return(1 || funcname || hash || result7 || libp) ;
9837}
9838
9839static int G__RootEventData_rootcint_208_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9840{
9841 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPathSM((Int_t) G__int(libp->para[0])));
9842 return(1 || funcname || hash || result7 || libp) ;
9843}
9844
9845static int G__RootEventData_rootcint_208_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9846{
9847 G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getNhits((Int_t) G__int(libp->para[0])));
9848 return(1 || funcname || hash || result7 || libp) ;
9849}
9850
9851static int G__RootEventData_rootcint_208_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9852{
9853 G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getNlayer((Int_t) G__int(libp->para[0])));
9854 return(1 || funcname || hash || result7 || libp) ;
9855}
9856
9857static int G__RootEventData_rootcint_208_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9858{
9859 G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getStat((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9860 return(1 || funcname || hash || result7 || libp) ;
9861}
9862
9863static int G__RootEventData_rootcint_208_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9864{
9865 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getChisq((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9866 return(1 || funcname || hash || result7 || libp) ;
9867}
9868
9869static int G__RootEventData_rootcint_208_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9870{
9871 G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getNdf((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9872 return(1 || funcname || hash || result7 || libp) ;
9873}
9874
9875static int G__RootEventData_rootcint_208_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9876{
9877 G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getNseg((Int_t) G__int(libp->para[0])));
9878 return(1 || funcname || hash || result7 || libp) ;
9879}
9880
9881static int G__RootEventData_rootcint_208_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9882{
9883 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelix((Int_t) G__int(libp->para[0])));
9884 return(1 || funcname || hash || result7 || libp) ;
9885}
9886
9887static int G__RootEventData_rootcint_208_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9888{
9889 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9890 return(1 || funcname || hash || result7 || libp) ;
9891}
9892
9893static int G__RootEventData_rootcint_208_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9894{
9895 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelixE((Int_t) G__int(libp->para[0])));
9896 return(1 || funcname || hash || result7 || libp) ;
9897}
9898
9899static int G__RootEventData_rootcint_208_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9900{
9901 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9902 return(1 || funcname || hash || result7 || libp) ;
9903}
9904
9905static int G__RootEventData_rootcint_208_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9906{
9907 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelixMu((Int_t) G__int(libp->para[0])));
9908 return(1 || funcname || hash || result7 || libp) ;
9909}
9910
9911static int G__RootEventData_rootcint_208_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9912{
9913 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9914 return(1 || funcname || hash || result7 || libp) ;
9915}
9916
9917static int G__RootEventData_rootcint_208_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9918{
9919 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelixK((Int_t) G__int(libp->para[0])));
9920 return(1 || funcname || hash || result7 || libp) ;
9921}
9922
9923static int G__RootEventData_rootcint_208_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9924{
9925 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9926 return(1 || funcname || hash || result7 || libp) ;
9927}
9928
9929static int G__RootEventData_rootcint_208_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9930{
9931 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelixP((Int_t) G__int(libp->para[0])));
9932 return(1 || funcname || hash || result7 || libp) ;
9933}
9934
9935static int G__RootEventData_rootcint_208_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9936{
9937 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9938 return(1 || funcname || hash || result7 || libp) ;
9939}
9940
9941static int G__RootEventData_rootcint_208_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9942{
9943 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelix((Int_t) G__int(libp->para[0])));
9944 return(1 || funcname || hash || result7 || libp) ;
9945}
9946
9947static int G__RootEventData_rootcint_208_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9948{
9949 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9950 return(1 || funcname || hash || result7 || libp) ;
9951}
9952
9953static int G__RootEventData_rootcint_208_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9954{
9955 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelixE((Int_t) G__int(libp->para[0])));
9956 return(1 || funcname || hash || result7 || libp) ;
9957}
9958
9959static int G__RootEventData_rootcint_208_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9960{
9961 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9962 return(1 || funcname || hash || result7 || libp) ;
9963}
9964
9965static int G__RootEventData_rootcint_208_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9966{
9967 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelixMu((Int_t) G__int(libp->para[0])));
9968 return(1 || funcname || hash || result7 || libp) ;
9969}
9970
9971static int G__RootEventData_rootcint_208_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9972{
9973 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9974 return(1 || funcname || hash || result7 || libp) ;
9975}
9976
9977static int G__RootEventData_rootcint_208_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9978{
9979 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelixK((Int_t) G__int(libp->para[0])));
9980 return(1 || funcname || hash || result7 || libp) ;
9981}
9982
9983static int G__RootEventData_rootcint_208_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9984{
9985 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9986 return(1 || funcname || hash || result7 || libp) ;
9987}
9988
9989static int G__RootEventData_rootcint_208_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9990{
9991 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelixP((Int_t) G__int(libp->para[0])));
9992 return(1 || funcname || hash || result7 || libp) ;
9993}
9994
9995static int G__RootEventData_rootcint_208_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9996{
9997 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9998 return(1 || funcname || hash || result7 || libp) ;
9999}
10000
10001static int G__RootEventData_rootcint_208_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10002{
10003 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelix((Int_t) G__int(libp->para[0])));
10004 return(1 || funcname || hash || result7 || libp) ;
10005}
10006
10007static int G__RootEventData_rootcint_208_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10008{
10009 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10010 return(1 || funcname || hash || result7 || libp) ;
10011}
10012
10013static int G__RootEventData_rootcint_208_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10014{
10015 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelixE((Int_t) G__int(libp->para[0])));
10016 return(1 || funcname || hash || result7 || libp) ;
10017}
10018
10019static int G__RootEventData_rootcint_208_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10020{
10021 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10022 return(1 || funcname || hash || result7 || libp) ;
10023}
10024
10025static int G__RootEventData_rootcint_208_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10026{
10027 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelixMu((Int_t) G__int(libp->para[0])));
10028 return(1 || funcname || hash || result7 || libp) ;
10029}
10030
10031static int G__RootEventData_rootcint_208_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10032{
10033 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10034 return(1 || funcname || hash || result7 || libp) ;
10035}
10036
10037static int G__RootEventData_rootcint_208_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10038{
10039 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelixK((Int_t) G__int(libp->para[0])));
10040 return(1 || funcname || hash || result7 || libp) ;
10041}
10042
10043static int G__RootEventData_rootcint_208_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10044{
10045 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10046 return(1 || funcname || hash || result7 || libp) ;
10047}
10048
10049static int G__RootEventData_rootcint_208_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10050{
10051 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelixP((Int_t) G__int(libp->para[0])));
10052 return(1 || funcname || hash || result7 || libp) ;
10053}
10054
10055static int G__RootEventData_rootcint_208_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10056{
10057 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10058 return(1 || funcname || hash || result7 || libp) ;
10059}
10060
10061static int G__RootEventData_rootcint_208_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10062{
10063 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getTHelix((Int_t) G__int(libp->para[0])));
10064 return(1 || funcname || hash || result7 || libp) ;
10065}
10066
10067static int G__RootEventData_rootcint_208_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10068{
10069 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getTError((Int_t) G__int(libp->para[0])));
10070 return(1 || funcname || hash || result7 || libp) ;
10071}
10072
10073static int G__RootEventData_rootcint_208_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10074{
10075 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPocaE((Int_t) G__int(libp->para[0])));
10076 return(1 || funcname || hash || result7 || libp) ;
10077}
10078
10079static int G__RootEventData_rootcint_208_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10080{
10081 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPocaMu((Int_t) G__int(libp->para[0])));
10082 return(1 || funcname || hash || result7 || libp) ;
10083}
10084
10085static int G__RootEventData_rootcint_208_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10086{
10087 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPoca((Int_t) G__int(libp->para[0])));
10088 return(1 || funcname || hash || result7 || libp) ;
10089}
10090
10091static int G__RootEventData_rootcint_208_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10092{
10093 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPocaK((Int_t) G__int(libp->para[0])));
10094 return(1 || funcname || hash || result7 || libp) ;
10095}
10096
10097static int G__RootEventData_rootcint_208_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10098{
10099 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPocaP((Int_t) G__int(libp->para[0])));
10100 return(1 || funcname || hash || result7 || libp) ;
10101}
10102
10103static int G__RootEventData_rootcint_208_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10104{
10105 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPointE((Int_t) G__int(libp->para[0])));
10106 return(1 || funcname || hash || result7 || libp) ;
10107}
10108
10109static int G__RootEventData_rootcint_208_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10110{
10111 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPointMu((Int_t) G__int(libp->para[0])));
10112 return(1 || funcname || hash || result7 || libp) ;
10113}
10114
10115static int G__RootEventData_rootcint_208_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10116{
10117 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPoint((Int_t) G__int(libp->para[0])));
10118 return(1 || funcname || hash || result7 || libp) ;
10119}
10120
10121static int G__RootEventData_rootcint_208_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10122{
10123 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPointK((Int_t) G__int(libp->para[0])));
10124 return(1 || funcname || hash || result7 || libp) ;
10125}
10126
10127static int G__RootEventData_rootcint_208_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10128{
10129 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPointP((Int_t) G__int(libp->para[0])));
10130 return(1 || funcname || hash || result7 || libp) ;
10131}
10132
10133static int G__RootEventData_rootcint_208_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10134{
10135 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivotE((Int_t) G__int(libp->para[0])));
10136 return(1 || funcname || hash || result7 || libp) ;
10137}
10138
10139static int G__RootEventData_rootcint_208_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10140{
10141 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivotMu((Int_t) G__int(libp->para[0])));
10142 return(1 || funcname || hash || result7 || libp) ;
10143}
10144
10145static int G__RootEventData_rootcint_208_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10146{
10147 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivot((Int_t) G__int(libp->para[0])));
10148 return(1 || funcname || hash || result7 || libp) ;
10149}
10150
10151static int G__RootEventData_rootcint_208_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10152{
10153 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivotK((Int_t) G__int(libp->para[0])));
10154 return(1 || funcname || hash || result7 || libp) ;
10155}
10156
10157static int G__RootEventData_rootcint_208_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10158{
10159 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivotP((Int_t) G__int(libp->para[0])));
10160 return(1 || funcname || hash || result7 || libp) ;
10161}
10162
10163static int G__RootEventData_rootcint_208_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10164{
10165 ((TRecMdcKalTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
10166 G__setnull(result7);
10167 return(1 || funcname || hash || result7 || libp) ;
10168}
10169
10170static int G__RootEventData_rootcint_208_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10171{
10172 ((TRecMdcKalTrack*) G__getstructoffset())->setMass((Double_t*) G__int(libp->para[0]));
10173 G__setnull(result7);
10174 return(1 || funcname || hash || result7 || libp) ;
10175}
10176
10177static int G__RootEventData_rootcint_208_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10178{
10179 ((TRecMdcKalTrack*) G__getstructoffset())->setLength((Double_t*) G__int(libp->para[0]));
10180 G__setnull(result7);
10181 return(1 || funcname || hash || result7 || libp) ;
10182}
10183
10184static int G__RootEventData_rootcint_208_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10185{
10186 ((TRecMdcKalTrack*) G__getstructoffset())->setFiTerm((Double_t*) G__int(libp->para[0]));
10187 G__setnull(result7);
10188 return(1 || funcname || hash || result7 || libp) ;
10189}
10190
10191static int G__RootEventData_rootcint_208_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10192{
10193 ((TRecMdcKalTrack*) G__getstructoffset())->setPathSM((Double_t*) G__int(libp->para[0]));
10194 G__setnull(result7);
10195 return(1 || funcname || hash || result7 || libp) ;
10196}
10197
10198static int G__RootEventData_rootcint_208_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10199{
10200 ((TRecMdcKalTrack*) G__getstructoffset())->setTof((Double_t*) G__int(libp->para[0]));
10201 G__setnull(result7);
10202 return(1 || funcname || hash || result7 || libp) ;
10203}
10204
10205static int G__RootEventData_rootcint_208_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10206{
10207 ((TRecMdcKalTrack*) G__getstructoffset())->setNhits((const Int_t*) G__int(libp->para[0]));
10208 G__setnull(result7);
10209 return(1 || funcname || hash || result7 || libp) ;
10210}
10211
10212static int G__RootEventData_rootcint_208_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10213{
10214 ((TRecMdcKalTrack*) G__getstructoffset())->setStat((const Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10215, (Int_t) G__int(libp->para[2]));
10216 G__setnull(result7);
10217 return(1 || funcname || hash || result7 || libp) ;
10218}
10219
10220static int G__RootEventData_rootcint_208_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10221{
10222 ((TRecMdcKalTrack*) G__getstructoffset())->setChisq((const Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])
10223, (Int_t) G__int(libp->para[2]));
10224 G__setnull(result7);
10225 return(1 || funcname || hash || result7 || libp) ;
10226}
10227
10228static int G__RootEventData_rootcint_208_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10229{
10230 ((TRecMdcKalTrack*) G__getstructoffset())->setNdf((const Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10231, (Int_t) G__int(libp->para[2]));
10232 G__setnull(result7);
10233 return(1 || funcname || hash || result7 || libp) ;
10234}
10235
10236static int G__RootEventData_rootcint_208_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10237{
10238 ((TRecMdcKalTrack*) G__getstructoffset())->setNseg((const Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10239 G__setnull(result7);
10240 return(1 || funcname || hash || result7 || libp) ;
10241}
10242
10243static int G__RootEventData_rootcint_208_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10244{
10245 ((TRecMdcKalTrack*) G__getstructoffset())->setNlayer((const Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10246 G__setnull(result7);
10247 return(1 || funcname || hash || result7 || libp) ;
10248}
10249
10250static int G__RootEventData_rootcint_208_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10251{
10252 ((TRecMdcKalTrack*) G__getstructoffset())->setZHelix((Double_t*) G__int(libp->para[0]));
10253 G__setnull(result7);
10254 return(1 || funcname || hash || result7 || libp) ;
10255}
10256
10257static int G__RootEventData_rootcint_208_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10258{
10259 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10260 ((TRecMdcKalTrack*) G__getstructoffset())->setZError(G__Ap0->a);
10261 G__setnull(result7);
10262 return(1 || funcname || hash || result7 || libp) ;
10263}
10264
10265static int G__RootEventData_rootcint_208_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10266{
10267 ((TRecMdcKalTrack*) G__getstructoffset())->setZHelixE((Double_t*) G__int(libp->para[0]));
10268 G__setnull(result7);
10269 return(1 || funcname || hash || result7 || libp) ;
10270}
10271
10272static int G__RootEventData_rootcint_208_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10273{
10274 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10275 ((TRecMdcKalTrack*) G__getstructoffset())->setZErrorE(G__Ap0->a);
10276 G__setnull(result7);
10277 return(1 || funcname || hash || result7 || libp) ;
10278}
10279
10280static int G__RootEventData_rootcint_208_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10281{
10282 ((TRecMdcKalTrack*) G__getstructoffset())->setZHelixMu((Double_t*) G__int(libp->para[0]));
10283 G__setnull(result7);
10284 return(1 || funcname || hash || result7 || libp) ;
10285}
10286
10287static int G__RootEventData_rootcint_208_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10288{
10289 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10290 ((TRecMdcKalTrack*) G__getstructoffset())->setZErrorMu(G__Ap0->a);
10291 G__setnull(result7);
10292 return(1 || funcname || hash || result7 || libp) ;
10293}
10294
10295static int G__RootEventData_rootcint_208_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10296{
10297 ((TRecMdcKalTrack*) G__getstructoffset())->setZHelixK((Double_t*) G__int(libp->para[0]));
10298 G__setnull(result7);
10299 return(1 || funcname || hash || result7 || libp) ;
10300}
10301
10302static int G__RootEventData_rootcint_208_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10303{
10304 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10305 ((TRecMdcKalTrack*) G__getstructoffset())->setZErrorK(G__Ap0->a);
10306 G__setnull(result7);
10307 return(1 || funcname || hash || result7 || libp) ;
10308}
10309
10310static int G__RootEventData_rootcint_208_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10311{
10312 ((TRecMdcKalTrack*) G__getstructoffset())->setZHelixP((Double_t*) G__int(libp->para[0]));
10313 G__setnull(result7);
10314 return(1 || funcname || hash || result7 || libp) ;
10315}
10316
10317static int G__RootEventData_rootcint_208_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10318{
10319 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10320 ((TRecMdcKalTrack*) G__getstructoffset())->setZErrorP(G__Ap0->a);
10321 G__setnull(result7);
10322 return(1 || funcname || hash || result7 || libp) ;
10323}
10324
10325static int G__RootEventData_rootcint_208_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10326{
10327 ((TRecMdcKalTrack*) G__getstructoffset())->setFHelix((Double_t*) G__int(libp->para[0]));
10328 G__setnull(result7);
10329 return(1 || funcname || hash || result7 || libp) ;
10330}
10331
10332static int G__RootEventData_rootcint_208_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10333{
10334 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10335 ((TRecMdcKalTrack*) G__getstructoffset())->setFError(G__Ap0->a);
10336 G__setnull(result7);
10337 return(1 || funcname || hash || result7 || libp) ;
10338}
10339
10340static int G__RootEventData_rootcint_208_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10341{
10342 ((TRecMdcKalTrack*) G__getstructoffset())->setFHelixE((Double_t*) G__int(libp->para[0]));
10343 G__setnull(result7);
10344 return(1 || funcname || hash || result7 || libp) ;
10345}
10346
10347static int G__RootEventData_rootcint_208_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10348{
10349 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10350 ((TRecMdcKalTrack*) G__getstructoffset())->setFErrorE(G__Ap0->a);
10351 G__setnull(result7);
10352 return(1 || funcname || hash || result7 || libp) ;
10353}
10354
10355static int G__RootEventData_rootcint_208_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10356{
10357 ((TRecMdcKalTrack*) G__getstructoffset())->setFHelixMu((Double_t*) G__int(libp->para[0]));
10358 G__setnull(result7);
10359 return(1 || funcname || hash || result7 || libp) ;
10360}
10361
10362static int G__RootEventData_rootcint_208_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10363{
10364 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10365 ((TRecMdcKalTrack*) G__getstructoffset())->setFErrorMu(G__Ap0->a);
10366 G__setnull(result7);
10367 return(1 || funcname || hash || result7 || libp) ;
10368}
10369
10370static int G__RootEventData_rootcint_208_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10371{
10372 ((TRecMdcKalTrack*) G__getstructoffset())->setFHelixK((Double_t*) G__int(libp->para[0]));
10373 G__setnull(result7);
10374 return(1 || funcname || hash || result7 || libp) ;
10375}
10376
10377static int G__RootEventData_rootcint_208_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10378{
10379 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10380 ((TRecMdcKalTrack*) G__getstructoffset())->setFErrorK(G__Ap0->a);
10381 G__setnull(result7);
10382 return(1 || funcname || hash || result7 || libp) ;
10383}
10384
10385static int G__RootEventData_rootcint_208_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10386{
10387 ((TRecMdcKalTrack*) G__getstructoffset())->setFHelixP((Double_t*) G__int(libp->para[0]));
10388 G__setnull(result7);
10389 return(1 || funcname || hash || result7 || libp) ;
10390}
10391
10392static int G__RootEventData_rootcint_208_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10393{
10394 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10395 ((TRecMdcKalTrack*) G__getstructoffset())->setFErrorP(G__Ap0->a);
10396 G__setnull(result7);
10397 return(1 || funcname || hash || result7 || libp) ;
10398}
10399
10400static int G__RootEventData_rootcint_208_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10401{
10402 ((TRecMdcKalTrack*) G__getstructoffset())->setLHelix((Double_t*) G__int(libp->para[0]));
10403 G__setnull(result7);
10404 return(1 || funcname || hash || result7 || libp) ;
10405}
10406
10407static int G__RootEventData_rootcint_208_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10408{
10409 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10410 ((TRecMdcKalTrack*) G__getstructoffset())->setLError(G__Ap0->a);
10411 G__setnull(result7);
10412 return(1 || funcname || hash || result7 || libp) ;
10413}
10414
10415static int G__RootEventData_rootcint_208_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10416{
10417 ((TRecMdcKalTrack*) G__getstructoffset())->setLHelixE((Double_t*) G__int(libp->para[0]));
10418 G__setnull(result7);
10419 return(1 || funcname || hash || result7 || libp) ;
10420}
10421
10422static int G__RootEventData_rootcint_208_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10423{
10424 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10425 ((TRecMdcKalTrack*) G__getstructoffset())->setLErrorE(G__Ap0->a);
10426 G__setnull(result7);
10427 return(1 || funcname || hash || result7 || libp) ;
10428}
10429
10430static int G__RootEventData_rootcint_208_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10431{
10432 ((TRecMdcKalTrack*) G__getstructoffset())->setLHelixMu((Double_t*) G__int(libp->para[0]));
10433 G__setnull(result7);
10434 return(1 || funcname || hash || result7 || libp) ;
10435}
10436
10437static int G__RootEventData_rootcint_208_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10438{
10439 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10440 ((TRecMdcKalTrack*) G__getstructoffset())->setLErrorMu(G__Ap0->a);
10441 G__setnull(result7);
10442 return(1 || funcname || hash || result7 || libp) ;
10443}
10444
10445static int G__RootEventData_rootcint_208_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10446{
10447 ((TRecMdcKalTrack*) G__getstructoffset())->setLHelixK((Double_t*) G__int(libp->para[0]));
10448 G__setnull(result7);
10449 return(1 || funcname || hash || result7 || libp) ;
10450}
10451
10452static int G__RootEventData_rootcint_208_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10453{
10454 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10455 ((TRecMdcKalTrack*) G__getstructoffset())->setLErrorK(G__Ap0->a);
10456 G__setnull(result7);
10457 return(1 || funcname || hash || result7 || libp) ;
10458}
10459
10460static int G__RootEventData_rootcint_208_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10461{
10462 ((TRecMdcKalTrack*) G__getstructoffset())->setLHelixP((Double_t*) G__int(libp->para[0]));
10463 G__setnull(result7);
10464 return(1 || funcname || hash || result7 || libp) ;
10465}
10466
10467static int G__RootEventData_rootcint_208_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10468{
10469 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10470 ((TRecMdcKalTrack*) G__getstructoffset())->setLErrorP(G__Ap0->a);
10471 G__setnull(result7);
10472 return(1 || funcname || hash || result7 || libp) ;
10473}
10474
10475static int G__RootEventData_rootcint_208_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10476{
10477 ((TRecMdcKalTrack*) G__getstructoffset())->setTHelix((Double_t*) G__int(libp->para[0]));
10478 G__setnull(result7);
10479 return(1 || funcname || hash || result7 || libp) ;
10480}
10481
10482static int G__RootEventData_rootcint_208_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10483{
10484 ((TRecMdcKalTrack*) G__getstructoffset())->setTError((Double_t*) G__int(libp->para[0]));
10485 G__setnull(result7);
10486 return(1 || funcname || hash || result7 || libp) ;
10487}
10488
10489static int G__RootEventData_rootcint_208_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10490{
10491 ((TRecMdcKalTrack*) G__getstructoffset())->setPocaE((Double_t*) G__int(libp->para[0]));
10492 G__setnull(result7);
10493 return(1 || funcname || hash || result7 || libp) ;
10494}
10495
10496static int G__RootEventData_rootcint_208_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10497{
10498 ((TRecMdcKalTrack*) G__getstructoffset())->setPocaMu((Double_t*) G__int(libp->para[0]));
10499 G__setnull(result7);
10500 return(1 || funcname || hash || result7 || libp) ;
10501}
10502
10503static int G__RootEventData_rootcint_208_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10504{
10505 ((TRecMdcKalTrack*) G__getstructoffset())->setPoca((Double_t*) G__int(libp->para[0]));
10506 G__setnull(result7);
10507 return(1 || funcname || hash || result7 || libp) ;
10508}
10509
10510static int G__RootEventData_rootcint_208_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10511{
10512 ((TRecMdcKalTrack*) G__getstructoffset())->setPocaK((Double_t*) G__int(libp->para[0]));
10513 G__setnull(result7);
10514 return(1 || funcname || hash || result7 || libp) ;
10515}
10516
10517static int G__RootEventData_rootcint_208_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10518{
10519 ((TRecMdcKalTrack*) G__getstructoffset())->setPocaP((Double_t*) G__int(libp->para[0]));
10520 G__setnull(result7);
10521 return(1 || funcname || hash || result7 || libp) ;
10522}
10523
10524static int G__RootEventData_rootcint_208_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10525{
10526 ((TRecMdcKalTrack*) G__getstructoffset())->setLPointE((Double_t*) G__int(libp->para[0]));
10527 G__setnull(result7);
10528 return(1 || funcname || hash || result7 || libp) ;
10529}
10530
10531static int G__RootEventData_rootcint_208_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10532{
10533 ((TRecMdcKalTrack*) G__getstructoffset())->setLPointMu((Double_t*) G__int(libp->para[0]));
10534 G__setnull(result7);
10535 return(1 || funcname || hash || result7 || libp) ;
10536}
10537
10538static int G__RootEventData_rootcint_208_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10539{
10540 ((TRecMdcKalTrack*) G__getstructoffset())->setLPoint((Double_t*) G__int(libp->para[0]));
10541 G__setnull(result7);
10542 return(1 || funcname || hash || result7 || libp) ;
10543}
10544
10545static int G__RootEventData_rootcint_208_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10546{
10547 ((TRecMdcKalTrack*) G__getstructoffset())->setLPointK((Double_t*) G__int(libp->para[0]));
10548 G__setnull(result7);
10549 return(1 || funcname || hash || result7 || libp) ;
10550}
10551
10552static int G__RootEventData_rootcint_208_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10553{
10554 ((TRecMdcKalTrack*) G__getstructoffset())->setLPointP((Double_t*) G__int(libp->para[0]));
10555 G__setnull(result7);
10556 return(1 || funcname || hash || result7 || libp) ;
10557}
10558
10559static int G__RootEventData_rootcint_208_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10560{
10561 ((TRecMdcKalTrack*) G__getstructoffset())->setLPivotE((Double_t*) G__int(libp->para[0]));
10562 G__setnull(result7);
10563 return(1 || funcname || hash || result7 || libp) ;
10564}
10565
10566static int G__RootEventData_rootcint_208_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10567{
10568 ((TRecMdcKalTrack*) G__getstructoffset())->setLPivotMu((Double_t*) G__int(libp->para[0]));
10569 G__setnull(result7);
10570 return(1 || funcname || hash || result7 || libp) ;
10571}
10572
10573static int G__RootEventData_rootcint_208_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10574{
10575 ((TRecMdcKalTrack*) G__getstructoffset())->setLPivot((Double_t*) G__int(libp->para[0]));
10576 G__setnull(result7);
10577 return(1 || funcname || hash || result7 || libp) ;
10578}
10579
10580static int G__RootEventData_rootcint_208_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10581{
10582 ((TRecMdcKalTrack*) G__getstructoffset())->setLPivotK((Double_t*) G__int(libp->para[0]));
10583 G__setnull(result7);
10584 return(1 || funcname || hash || result7 || libp) ;
10585}
10586
10587static int G__RootEventData_rootcint_208_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10588{
10589 ((TRecMdcKalTrack*) G__getstructoffset())->setLPivotP((Double_t*) G__int(libp->para[0]));
10590 G__setnull(result7);
10591 return(1 || funcname || hash || result7 || libp) ;
10592}
10593
10594static int G__RootEventData_rootcint_208_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10595{
10596 G__letint(result7, 85, (long) TRecMdcKalTrack::Class());
10597 return(1 || funcname || hash || result7 || libp) ;
10598}
10599
10600static int G__RootEventData_rootcint_208_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10601{
10602 G__letint(result7, 67, (long) TRecMdcKalTrack::Class_Name());
10603 return(1 || funcname || hash || result7 || libp) ;
10604}
10605
10606static int G__RootEventData_rootcint_208_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10607{
10608 G__letint(result7, 115, (long) TRecMdcKalTrack::Class_Version());
10609 return(1 || funcname || hash || result7 || libp) ;
10610}
10611
10612static int G__RootEventData_rootcint_208_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10613{
10614 TRecMdcKalTrack::Dictionary();
10615 G__setnull(result7);
10616 return(1 || funcname || hash || result7 || libp) ;
10617}
10618
10619static int G__RootEventData_rootcint_208_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10620{
10621 ((TRecMdcKalTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10622 G__setnull(result7);
10623 return(1 || funcname || hash || result7 || libp) ;
10624}
10625
10626static int G__RootEventData_rootcint_208_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10627{
10628 G__letint(result7, 67, (long) TRecMdcKalTrack::DeclFileName());
10629 return(1 || funcname || hash || result7 || libp) ;
10630}
10631
10632static int G__RootEventData_rootcint_208_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10633{
10634 G__letint(result7, 105, (long) TRecMdcKalTrack::ImplFileLine());
10635 return(1 || funcname || hash || result7 || libp) ;
10636}
10637
10638static int G__RootEventData_rootcint_208_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10639{
10640 G__letint(result7, 67, (long) TRecMdcKalTrack::ImplFileName());
10641 return(1 || funcname || hash || result7 || libp) ;
10642}
10643
10644static int G__RootEventData_rootcint_208_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10645{
10646 G__letint(result7, 105, (long) TRecMdcKalTrack::DeclFileLine());
10647 return(1 || funcname || hash || result7 || libp) ;
10648}
10649
10650// automatic copy constructor
10651static int G__RootEventData_rootcint_208_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10652
10653{
10654 TRecMdcKalTrack* p;
10655 void* tmp = (void*) G__int(libp->para[0]);
10656 p = new TRecMdcKalTrack(*(TRecMdcKalTrack*) tmp);
10657 result7->obj.i = (long) p;
10658 result7->ref = (long) p;
10659 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack));
10660 return(1 || funcname || hash || result7 || libp) ;
10661}
10662
10663// automatic destructor
10664typedef TRecMdcKalTrack G__TTRecMdcKalTrack;
10665static int G__RootEventData_rootcint_208_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10666{
10667 char* gvp = (char*) G__getgvp();
10668 long soff = G__getstructoffset();
10669 int n = G__getaryconstruct();
10670 //
10671 //has_a_delete: 1
10672 //has_own_delete1arg: 0
10673 //has_own_delete2arg: 0
10674 //
10675 if (!soff) {
10676 return(1);
10677 }
10678 if (n) {
10679 if (gvp == (char*)G__PVOID) {
10680 delete[] (TRecMdcKalTrack*) soff;
10681 } else {
10682 G__setgvp((long) G__PVOID);
10683 for (int i = n - 1; i >= 0; --i) {
10684 ((TRecMdcKalTrack*) (soff+(sizeof(TRecMdcKalTrack)*i)))->~G__TTRecMdcKalTrack();
10685 }
10686 G__setgvp((long)gvp);
10687 }
10688 } else {
10689 if (gvp == (char*)G__PVOID) {
10690 delete (TRecMdcKalTrack*) soff;
10691 } else {
10692 G__setgvp((long) G__PVOID);
10693 ((TRecMdcKalTrack*) (soff))->~G__TTRecMdcKalTrack();
10694 G__setgvp((long)gvp);
10695 }
10696 }
10697 G__setnull(result7);
10698 return(1 || funcname || hash || result7 || libp) ;
10699}
10700
10701// automatic assignment operator
10702static int G__RootEventData_rootcint_208_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10703{
10704 TRecMdcKalTrack* dest = (TRecMdcKalTrack*) G__getstructoffset();
10705 *dest = *(TRecMdcKalTrack*) libp->para[0].ref;
10706 const TRecMdcKalTrack& obj = *dest;
10707 result7->ref = (long) (&obj);
10708 result7->obj.i = (long) (&obj);
10709 return(1 || funcname || hash || result7 || libp) ;
10710}
10711
10712
10713/* TRecMdcHit */
10714static int G__RootEventData_rootcint_209_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10715{
10716 TRecMdcHit* p = NULL;
10717 char* gvp = (char*) G__getgvp();
10718 int n = G__getaryconstruct();
10719 if (n) {
10720 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10721 p = new TRecMdcHit[n];
10722 } else {
10723 p = new((void*) gvp) TRecMdcHit[n];
10724 }
10725 } else {
10726 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10727 p = new TRecMdcHit;
10728 } else {
10729 p = new((void*) gvp) TRecMdcHit;
10730 }
10731 }
10732 result7->obj.i = (long) p;
10733 result7->ref = (long) p;
10734 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit));
10735 return(1 || funcname || hash || result7 || libp) ;
10736}
10737
10738static int G__RootEventData_rootcint_209_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10739{
10740 G__letint(result7, 103, (long) ((const TRecMdcHit*) G__getstructoffset())->isGrouped());
10741 return(1 || funcname || hash || result7 || libp) ;
10742}
10743
10744static int G__RootEventData_rootcint_209_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10745{
10746 G__letint(result7, 105, (long) ((const TRecMdcHit*) G__getstructoffset())->getId());
10747 return(1 || funcname || hash || result7 || libp) ;
10748}
10749
10750static int G__RootEventData_rootcint_209_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10751{
10752 G__letint(result7, 105, (long) ((const TRecMdcHit*) G__getstructoffset())->getTrkId());
10753 return(1 || funcname || hash || result7 || libp) ;
10754}
10755
10756static int G__RootEventData_rootcint_209_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10757{
10758 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getDriftDistLeft());
10759 return(1 || funcname || hash || result7 || libp) ;
10760}
10761
10762static int G__RootEventData_rootcint_209_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10763{
10764 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getDriftDistRight());
10765 return(1 || funcname || hash || result7 || libp) ;
10766}
10767
10768static int G__RootEventData_rootcint_209_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10769{
10770 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getErrDriftDistLeft());
10771 return(1 || funcname || hash || result7 || libp) ;
10772}
10773
10774static int G__RootEventData_rootcint_209_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10775{
10776 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getErrDriftDistRight());
10777 return(1 || funcname || hash || result7 || libp) ;
10778}
10779
10780static int G__RootEventData_rootcint_209_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10781{
10782 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getChisqAdd());
10783 return(1 || funcname || hash || result7 || libp) ;
10784}
10785
10786static int G__RootEventData_rootcint_209_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10787{
10788 G__letint(result7, 105, (long) ((const TRecMdcHit*) G__getstructoffset())->getFlagLR());
10789 return(1 || funcname || hash || result7 || libp) ;
10790}
10791
10792static int G__RootEventData_rootcint_209_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10793{
10794 G__letint(result7, 105, (long) ((const TRecMdcHit*) G__getstructoffset())->getStat());
10795 return(1 || funcname || hash || result7 || libp) ;
10796}
10797
10798static int G__RootEventData_rootcint_209_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10799{
10800 G__letint(result7, 104, (long) ((const TRecMdcHit*) G__getstructoffset())->getMdcId());
10801 return(1 || funcname || hash || result7 || libp) ;
10802}
10803
10804static int G__RootEventData_rootcint_209_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10805{
10806 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getTdc());
10807 return(1 || funcname || hash || result7 || libp) ;
10808}
10809
10810static int G__RootEventData_rootcint_209_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10811{
10812 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getAdc());
10813 return(1 || funcname || hash || result7 || libp) ;
10814}
10815
10816static int G__RootEventData_rootcint_209_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10817{
10818 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getDriftT());
10819 return(1 || funcname || hash || result7 || libp) ;
10820}
10821
10822static int G__RootEventData_rootcint_209_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10823{
10824 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getDoca());
10825 return(1 || funcname || hash || result7 || libp) ;
10826}
10827
10828static int G__RootEventData_rootcint_209_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10829{
10830 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getEntra());
10831 return(1 || funcname || hash || result7 || libp) ;
10832}
10833
10834static int G__RootEventData_rootcint_209_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10835{
10836 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getZhit());
10837 return(1 || funcname || hash || result7 || libp) ;
10838}
10839
10840static int G__RootEventData_rootcint_209_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10841{
10842 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getFltLen());
10843 return(1 || funcname || hash || result7 || libp) ;
10844}
10845
10846static int G__RootEventData_rootcint_209_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10847{
10848 ((TRecMdcHit*) G__getstructoffset())->setIsGrouped((Bool_t) G__int(libp->para[0]));
10849 G__setnull(result7);
10850 return(1 || funcname || hash || result7 || libp) ;
10851}
10852
10853static int G__RootEventData_rootcint_209_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10854{
10855 ((TRecMdcHit*) G__getstructoffset())->setId((Int_t) G__int(libp->para[0]));
10856 G__setnull(result7);
10857 return(1 || funcname || hash || result7 || libp) ;
10858}
10859
10860static int G__RootEventData_rootcint_209_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10861{
10862 ((TRecMdcHit*) G__getstructoffset())->setTrkId((Int_t) G__int(libp->para[0]));
10863 G__setnull(result7);
10864 return(1 || funcname || hash || result7 || libp) ;
10865}
10866
10867static int G__RootEventData_rootcint_209_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10868{
10869 ((TRecMdcHit*) G__getstructoffset())->setDriftDistLeft((Double_t) G__double(libp->para[0]));
10870 G__setnull(result7);
10871 return(1 || funcname || hash || result7 || libp) ;
10872}
10873
10874static int G__RootEventData_rootcint_209_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10875{
10876 ((TRecMdcHit*) G__getstructoffset())->setDriftDistRight((Double_t) G__double(libp->para[0]));
10877 G__setnull(result7);
10878 return(1 || funcname || hash || result7 || libp) ;
10879}
10880
10881static int G__RootEventData_rootcint_209_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10882{
10883 ((TRecMdcHit*) G__getstructoffset())->setErrDriftDistLeft((Double_t) G__double(libp->para[0]));
10884 G__setnull(result7);
10885 return(1 || funcname || hash || result7 || libp) ;
10886}
10887
10888static int G__RootEventData_rootcint_209_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10889{
10890 ((TRecMdcHit*) G__getstructoffset())->setErrDriftDistRight((Double_t) G__double(libp->para[0]));
10891 G__setnull(result7);
10892 return(1 || funcname || hash || result7 || libp) ;
10893}
10894
10895static int G__RootEventData_rootcint_209_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10896{
10897 ((TRecMdcHit*) G__getstructoffset())->setChisqAdd((Double_t) G__double(libp->para[0]));
10898 G__setnull(result7);
10899 return(1 || funcname || hash || result7 || libp) ;
10900}
10901
10902static int G__RootEventData_rootcint_209_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10903{
10904 ((TRecMdcHit*) G__getstructoffset())->setFlagLR((Int_t) G__int(libp->para[0]));
10905 G__setnull(result7);
10906 return(1 || funcname || hash || result7 || libp) ;
10907}
10908
10909static int G__RootEventData_rootcint_209_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10910{
10911 ((TRecMdcHit*) G__getstructoffset())->setStat((Int_t) G__int(libp->para[0]));
10912 G__setnull(result7);
10913 return(1 || funcname || hash || result7 || libp) ;
10914}
10915
10916static int G__RootEventData_rootcint_209_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10917{
10918 ((TRecMdcHit*) G__getstructoffset())->setMdcId((UInt_t) G__int(libp->para[0]));
10919 G__setnull(result7);
10920 return(1 || funcname || hash || result7 || libp) ;
10921}
10922
10923static int G__RootEventData_rootcint_209_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10924{
10925 ((TRecMdcHit*) G__getstructoffset())->setTdc((Double_t) G__double(libp->para[0]));
10926 G__setnull(result7);
10927 return(1 || funcname || hash || result7 || libp) ;
10928}
10929
10930static int G__RootEventData_rootcint_209_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10931{
10932 ((TRecMdcHit*) G__getstructoffset())->setAdc((Double_t) G__double(libp->para[0]));
10933 G__setnull(result7);
10934 return(1 || funcname || hash || result7 || libp) ;
10935}
10936
10937static int G__RootEventData_rootcint_209_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10938{
10939 ((TRecMdcHit*) G__getstructoffset())->setDriftT((Double_t) G__double(libp->para[0]));
10940 G__setnull(result7);
10941 return(1 || funcname || hash || result7 || libp) ;
10942}
10943
10944static int G__RootEventData_rootcint_209_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10945{
10946 ((TRecMdcHit*) G__getstructoffset())->setDoca((Double_t) G__double(libp->para[0]));
10947 G__setnull(result7);
10948 return(1 || funcname || hash || result7 || libp) ;
10949}
10950
10951static int G__RootEventData_rootcint_209_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10952{
10953 ((TRecMdcHit*) G__getstructoffset())->setEntra((Double_t) G__double(libp->para[0]));
10954 G__setnull(result7);
10955 return(1 || funcname || hash || result7 || libp) ;
10956}
10957
10958static int G__RootEventData_rootcint_209_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10959{
10960 ((TRecMdcHit*) G__getstructoffset())->setZhit((Double_t) G__double(libp->para[0]));
10961 G__setnull(result7);
10962 return(1 || funcname || hash || result7 || libp) ;
10963}
10964
10965static int G__RootEventData_rootcint_209_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10966{
10967 ((TRecMdcHit*) G__getstructoffset())->setFltLen((Double_t) G__double(libp->para[0]));
10968 G__setnull(result7);
10969 return(1 || funcname || hash || result7 || libp) ;
10970}
10971
10972static int G__RootEventData_rootcint_209_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10973{
10974 ((TRecMdcHit*) G__getstructoffset())->setTRecMdcHit((TRecMdcHit*) G__int(libp->para[0]));
10975 G__setnull(result7);
10976 return(1 || funcname || hash || result7 || libp) ;
10977}
10978
10979static int G__RootEventData_rootcint_209_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10980{
10981 G__letint(result7, 85, (long) TRecMdcHit::Class());
10982 return(1 || funcname || hash || result7 || libp) ;
10983}
10984
10985static int G__RootEventData_rootcint_209_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10986{
10987 G__letint(result7, 67, (long) TRecMdcHit::Class_Name());
10988 return(1 || funcname || hash || result7 || libp) ;
10989}
10990
10991static int G__RootEventData_rootcint_209_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10992{
10993 G__letint(result7, 115, (long) TRecMdcHit::Class_Version());
10994 return(1 || funcname || hash || result7 || libp) ;
10995}
10996
10997static int G__RootEventData_rootcint_209_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10998{
10999 TRecMdcHit::Dictionary();
11000 G__setnull(result7);
11001 return(1 || funcname || hash || result7 || libp) ;
11002}
11003
11004static int G__RootEventData_rootcint_209_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11005{
11006 ((TRecMdcHit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11007 G__setnull(result7);
11008 return(1 || funcname || hash || result7 || libp) ;
11009}
11010
11011static int G__RootEventData_rootcint_209_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11012{
11013 G__letint(result7, 67, (long) TRecMdcHit::DeclFileName());
11014 return(1 || funcname || hash || result7 || libp) ;
11015}
11016
11017static int G__RootEventData_rootcint_209_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11018{
11019 G__letint(result7, 105, (long) TRecMdcHit::ImplFileLine());
11020 return(1 || funcname || hash || result7 || libp) ;
11021}
11022
11023static int G__RootEventData_rootcint_209_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11024{
11025 G__letint(result7, 67, (long) TRecMdcHit::ImplFileName());
11026 return(1 || funcname || hash || result7 || libp) ;
11027}
11028
11029static int G__RootEventData_rootcint_209_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11030{
11031 G__letint(result7, 105, (long) TRecMdcHit::DeclFileLine());
11032 return(1 || funcname || hash || result7 || libp) ;
11033}
11034
11035// automatic copy constructor
11036static int G__RootEventData_rootcint_209_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11037
11038{
11039 TRecMdcHit* p;
11040 void* tmp = (void*) G__int(libp->para[0]);
11041 p = new TRecMdcHit(*(TRecMdcHit*) tmp);
11042 result7->obj.i = (long) p;
11043 result7->ref = (long) p;
11044 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit));
11045 return(1 || funcname || hash || result7 || libp) ;
11046}
11047
11048// automatic destructor
11049typedef TRecMdcHit G__TTRecMdcHit;
11050static int G__RootEventData_rootcint_209_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11051{
11052 char* gvp = (char*) G__getgvp();
11053 long soff = G__getstructoffset();
11054 int n = G__getaryconstruct();
11055 //
11056 //has_a_delete: 1
11057 //has_own_delete1arg: 0
11058 //has_own_delete2arg: 0
11059 //
11060 if (!soff) {
11061 return(1);
11062 }
11063 if (n) {
11064 if (gvp == (char*)G__PVOID) {
11065 delete[] (TRecMdcHit*) soff;
11066 } else {
11067 G__setgvp((long) G__PVOID);
11068 for (int i = n - 1; i >= 0; --i) {
11069 ((TRecMdcHit*) (soff+(sizeof(TRecMdcHit)*i)))->~G__TTRecMdcHit();
11070 }
11071 G__setgvp((long)gvp);
11072 }
11073 } else {
11074 if (gvp == (char*)G__PVOID) {
11075 delete (TRecMdcHit*) soff;
11076 } else {
11077 G__setgvp((long) G__PVOID);
11078 ((TRecMdcHit*) (soff))->~G__TTRecMdcHit();
11079 G__setgvp((long)gvp);
11080 }
11081 }
11082 G__setnull(result7);
11083 return(1 || funcname || hash || result7 || libp) ;
11084}
11085
11086// automatic assignment operator
11087static int G__RootEventData_rootcint_209_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11088{
11089 TRecMdcHit* dest = (TRecMdcHit*) G__getstructoffset();
11090 *dest = *(TRecMdcHit*) libp->para[0].ref;
11091 const TRecMdcHit& obj = *dest;
11092 result7->ref = (long) (&obj);
11093 result7->obj.i = (long) (&obj);
11094 return(1 || funcname || hash || result7 || libp) ;
11095}
11096
11097
11098/* TTofTrack */
11099static int G__RootEventData_rootcint_210_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11100{
11101 TTofTrack* p = NULL;
11102 char* gvp = (char*) G__getgvp();
11103 int n = G__getaryconstruct();
11104 if (n) {
11105 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11106 p = new TTofTrack[n];
11107 } else {
11108 p = new((void*) gvp) TTofTrack[n];
11109 }
11110 } else {
11111 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11112 p = new TTofTrack;
11113 } else {
11114 p = new((void*) gvp) TTofTrack;
11115 }
11116 }
11117 result7->obj.i = (long) p;
11118 result7->ref = (long) p;
11119 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack));
11120 return(1 || funcname || hash || result7 || libp) ;
11121}
11122
11123static int G__RootEventData_rootcint_210_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11124{
11125 ((TTofTrack*) G__getstructoffset())->setTofTrackID((Int_t) G__int(libp->para[0]));
11126 G__setnull(result7);
11127 return(1 || funcname || hash || result7 || libp) ;
11128}
11129
11130static int G__RootEventData_rootcint_210_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11131{
11132 ((TTofTrack*) G__getstructoffset())->setTrackID((Int_t) G__int(libp->para[0]));
11133 G__setnull(result7);
11134 return(1 || funcname || hash || result7 || libp) ;
11135}
11136
11137static int G__RootEventData_rootcint_210_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11138{
11139 ((TTofTrack*) G__getstructoffset())->setTofID((Int_t) G__int(libp->para[0]));
11140 G__setnull(result7);
11141 return(1 || funcname || hash || result7 || libp) ;
11142}
11143
11144static int G__RootEventData_rootcint_210_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11145{
11146 ((TTofTrack*) G__getstructoffset())->setStatus((UInt_t) G__int(libp->para[0]));
11147 G__setnull(result7);
11148 return(1 || funcname || hash || result7 || libp) ;
11149}
11150
11151static int G__RootEventData_rootcint_210_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11152{
11153 ((TTofTrack*) G__getstructoffset())->setPath((Double_t) G__double(libp->para[0]));
11154 G__setnull(result7);
11155 return(1 || funcname || hash || result7 || libp) ;
11156}
11157
11158static int G__RootEventData_rootcint_210_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11159{
11160 ((TTofTrack*) G__getstructoffset())->setZrHit((Double_t) G__double(libp->para[0]));
11161 G__setnull(result7);
11162 return(1 || funcname || hash || result7 || libp) ;
11163}
11164
11165static int G__RootEventData_rootcint_210_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11166{
11167 ((TTofTrack*) G__getstructoffset())->setPh((Double_t) G__double(libp->para[0]));
11168 G__setnull(result7);
11169 return(1 || funcname || hash || result7 || libp) ;
11170}
11171
11172static int G__RootEventData_rootcint_210_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11173{
11174 ((TTofTrack*) G__getstructoffset())->setTof((Double_t) G__double(libp->para[0]));
11175 G__setnull(result7);
11176 return(1 || funcname || hash || result7 || libp) ;
11177}
11178
11179static int G__RootEventData_rootcint_210_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11180{
11181 ((TTofTrack*) G__getstructoffset())->setErrTof((Double_t) G__double(libp->para[0]));
11182 G__setnull(result7);
11183 return(1 || funcname || hash || result7 || libp) ;
11184}
11185
11186static int G__RootEventData_rootcint_210_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11187{
11188 ((TTofTrack*) G__getstructoffset())->setBeta((Double_t) G__double(libp->para[0]));
11189 G__setnull(result7);
11190 return(1 || funcname || hash || result7 || libp) ;
11191}
11192
11193static int G__RootEventData_rootcint_210_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11194{
11195 ((TTofTrack*) G__getstructoffset())->setTexp((Double_t*) G__int(libp->para[0]));
11196 G__setnull(result7);
11197 return(1 || funcname || hash || result7 || libp) ;
11198}
11199
11200static int G__RootEventData_rootcint_210_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11201{
11202 ((TTofTrack*) G__getstructoffset())->setTexpElectron((Double_t) G__double(libp->para[0]));
11203 G__setnull(result7);
11204 return(1 || funcname || hash || result7 || libp) ;
11205}
11206
11207static int G__RootEventData_rootcint_210_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11208{
11209 ((TTofTrack*) G__getstructoffset())->setTexpMuon((Double_t) G__double(libp->para[0]));
11210 G__setnull(result7);
11211 return(1 || funcname || hash || result7 || libp) ;
11212}
11213
11214static int G__RootEventData_rootcint_210_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11215{
11216 ((TTofTrack*) G__getstructoffset())->setTexpPion((Double_t) G__double(libp->para[0]));
11217 G__setnull(result7);
11218 return(1 || funcname || hash || result7 || libp) ;
11219}
11220
11221static int G__RootEventData_rootcint_210_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11222{
11223 ((TTofTrack*) G__getstructoffset())->setTexpKaon((Double_t) G__double(libp->para[0]));
11224 G__setnull(result7);
11225 return(1 || funcname || hash || result7 || libp) ;
11226}
11227
11228static int G__RootEventData_rootcint_210_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11229{
11230 ((TTofTrack*) G__getstructoffset())->setTexpProton((Double_t) G__double(libp->para[0]));
11231 G__setnull(result7);
11232 return(1 || funcname || hash || result7 || libp) ;
11233}
11234
11235static int G__RootEventData_rootcint_210_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11236{
11237 ((TTofTrack*) G__getstructoffset())->setToffset((Double_t*) G__int(libp->para[0]));
11238 G__setnull(result7);
11239 return(1 || funcname || hash || result7 || libp) ;
11240}
11241
11242static int G__RootEventData_rootcint_210_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11243{
11244 ((TTofTrack*) G__getstructoffset())->setToffsetElectron((Double_t) G__double(libp->para[0]));
11245 G__setnull(result7);
11246 return(1 || funcname || hash || result7 || libp) ;
11247}
11248
11249static int G__RootEventData_rootcint_210_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11250{
11251 ((TTofTrack*) G__getstructoffset())->setToffsetMuon((Double_t) G__double(libp->para[0]));
11252 G__setnull(result7);
11253 return(1 || funcname || hash || result7 || libp) ;
11254}
11255
11256static int G__RootEventData_rootcint_210_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11257{
11258 ((TTofTrack*) G__getstructoffset())->setToffsetPion((Double_t) G__double(libp->para[0]));
11259 G__setnull(result7);
11260 return(1 || funcname || hash || result7 || libp) ;
11261}
11262
11263static int G__RootEventData_rootcint_210_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11264{
11265 ((TTofTrack*) G__getstructoffset())->setToffsetKaon((Double_t) G__double(libp->para[0]));
11266 G__setnull(result7);
11267 return(1 || funcname || hash || result7 || libp) ;
11268}
11269
11270static int G__RootEventData_rootcint_210_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11271{
11272 ((TTofTrack*) G__getstructoffset())->setToffsetProton((Double_t) G__double(libp->para[0]));
11273 G__setnull(result7);
11274 return(1 || funcname || hash || result7 || libp) ;
11275}
11276
11277static int G__RootEventData_rootcint_210_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11278{
11279 ((TTofTrack*) G__getstructoffset())->setToffsetAntiProton((Double_t) G__double(libp->para[0]));
11280 G__setnull(result7);
11281 return(1 || funcname || hash || result7 || libp) ;
11282}
11283
11284static int G__RootEventData_rootcint_210_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11285{
11286 ((TTofTrack*) G__getstructoffset())->setSigma((Double_t*) G__int(libp->para[0]));
11287 G__setnull(result7);
11288 return(1 || funcname || hash || result7 || libp) ;
11289}
11290
11291static int G__RootEventData_rootcint_210_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11292{
11293 ((TTofTrack*) G__getstructoffset())->setSigmaElectron((Double_t) G__double(libp->para[0]));
11294 G__setnull(result7);
11295 return(1 || funcname || hash || result7 || libp) ;
11296}
11297
11298static int G__RootEventData_rootcint_210_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11299{
11300 ((TTofTrack*) G__getstructoffset())->setSigmaMuon((Double_t) G__double(libp->para[0]));
11301 G__setnull(result7);
11302 return(1 || funcname || hash || result7 || libp) ;
11303}
11304
11305static int G__RootEventData_rootcint_210_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11306{
11307 ((TTofTrack*) G__getstructoffset())->setSigmaPion((Double_t) G__double(libp->para[0]));
11308 G__setnull(result7);
11309 return(1 || funcname || hash || result7 || libp) ;
11310}
11311
11312static int G__RootEventData_rootcint_210_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11313{
11314 ((TTofTrack*) G__getstructoffset())->setSigmaKaon((Double_t) G__double(libp->para[0]));
11315 G__setnull(result7);
11316 return(1 || funcname || hash || result7 || libp) ;
11317}
11318
11319static int G__RootEventData_rootcint_210_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11320{
11321 ((TTofTrack*) G__getstructoffset())->setSigmaProton((Double_t) G__double(libp->para[0]));
11322 G__setnull(result7);
11323 return(1 || funcname || hash || result7 || libp) ;
11324}
11325
11326static int G__RootEventData_rootcint_210_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11327{
11328 ((TTofTrack*) G__getstructoffset())->setSigmaAntiProton((Double_t) G__double(libp->para[0]));
11329 G__setnull(result7);
11330 return(1 || funcname || hash || result7 || libp) ;
11331}
11332
11333static int G__RootEventData_rootcint_210_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11334{
11335 ((TTofTrack*) G__getstructoffset())->setQuality((Int_t) G__int(libp->para[0]));
11336 G__setnull(result7);
11337 return(1 || funcname || hash || result7 || libp) ;
11338}
11339
11340static int G__RootEventData_rootcint_210_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11341{
11342 ((TTofTrack*) G__getstructoffset())->setT0((Double_t) G__double(libp->para[0]));
11343 G__setnull(result7);
11344 return(1 || funcname || hash || result7 || libp) ;
11345}
11346
11347static int G__RootEventData_rootcint_210_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11348{
11349 ((TTofTrack*) G__getstructoffset())->setErrT0((Double_t) G__double(libp->para[0]));
11350 G__setnull(result7);
11351 return(1 || funcname || hash || result7 || libp) ;
11352}
11353
11354static int G__RootEventData_rootcint_210_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11355{
11356 ((TTofTrack*) G__getstructoffset())->setErrZ((Double_t) G__double(libp->para[0]));
11357 G__setnull(result7);
11358 return(1 || funcname || hash || result7 || libp) ;
11359}
11360
11361static int G__RootEventData_rootcint_210_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11362{
11363 ((TTofTrack*) G__getstructoffset())->setPhi((Double_t) G__double(libp->para[0]));
11364 G__setnull(result7);
11365 return(1 || funcname || hash || result7 || libp) ;
11366}
11367
11368static int G__RootEventData_rootcint_210_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11369{
11370 ((TTofTrack*) G__getstructoffset())->setErrPhi((Double_t) G__double(libp->para[0]));
11371 G__setnull(result7);
11372 return(1 || funcname || hash || result7 || libp) ;
11373}
11374
11375static int G__RootEventData_rootcint_210_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11376{
11377 ((TTofTrack*) G__getstructoffset())->setEnergy((Double_t) G__double(libp->para[0]));
11378 G__setnull(result7);
11379 return(1 || funcname || hash || result7 || libp) ;
11380}
11381
11382static int G__RootEventData_rootcint_210_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11383{
11384 ((TTofTrack*) G__getstructoffset())->setErrEnergy((Double_t) G__double(libp->para[0]));
11385 G__setnull(result7);
11386 return(1 || funcname || hash || result7 || libp) ;
11387}
11388
11389static int G__RootEventData_rootcint_210_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11390{
11391 G__letint(result7, 105, (long) ((const TTofTrack*) G__getstructoffset())->tofTrackID());
11392 return(1 || funcname || hash || result7 || libp) ;
11393}
11394
11395static int G__RootEventData_rootcint_210_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11396{
11397 G__letint(result7, 105, (long) ((const TTofTrack*) G__getstructoffset())->trackID());
11398 return(1 || funcname || hash || result7 || libp) ;
11399}
11400
11401static int G__RootEventData_rootcint_210_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11402{
11403 G__letint(result7, 105, (long) ((const TTofTrack*) G__getstructoffset())->tofID());
11404 return(1 || funcname || hash || result7 || libp) ;
11405}
11406
11407static int G__RootEventData_rootcint_210_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11408{
11409 G__letint(result7, 104, (long) ((const TTofTrack*) G__getstructoffset())->status());
11410 return(1 || funcname || hash || result7 || libp) ;
11411}
11412
11413static int G__RootEventData_rootcint_210_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11414{
11415 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->path());
11416 return(1 || funcname || hash || result7 || libp) ;
11417}
11418
11419static int G__RootEventData_rootcint_210_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11420{
11421 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->zrhit());
11422 return(1 || funcname || hash || result7 || libp) ;
11423}
11424
11425static int G__RootEventData_rootcint_210_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11426{
11427 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->ph());
11428 return(1 || funcname || hash || result7 || libp) ;
11429}
11430
11431static int G__RootEventData_rootcint_210_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11432{
11433 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->tof());
11434 return(1 || funcname || hash || result7 || libp) ;
11435}
11436
11437static int G__RootEventData_rootcint_210_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11438{
11439 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errtof());
11440 return(1 || funcname || hash || result7 || libp) ;
11441}
11442
11443static int G__RootEventData_rootcint_210_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11444{
11445 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->beta());
11446 return(1 || funcname || hash || result7 || libp) ;
11447}
11448
11449static int G__RootEventData_rootcint_210_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11450{
11451 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texp((Int_t) G__int(libp->para[0])));
11452 return(1 || funcname || hash || result7 || libp) ;
11453}
11454
11455static int G__RootEventData_rootcint_210_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11456{
11457 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpElectron());
11458 return(1 || funcname || hash || result7 || libp) ;
11459}
11460
11461static int G__RootEventData_rootcint_210_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11462{
11463 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpMuon());
11464 return(1 || funcname || hash || result7 || libp) ;
11465}
11466
11467static int G__RootEventData_rootcint_210_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11468{
11469 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpPion());
11470 return(1 || funcname || hash || result7 || libp) ;
11471}
11472
11473static int G__RootEventData_rootcint_210_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11474{
11475 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpKaon());
11476 return(1 || funcname || hash || result7 || libp) ;
11477}
11478
11479static int G__RootEventData_rootcint_210_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11480{
11481 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpProton());
11482 return(1 || funcname || hash || result7 || libp) ;
11483}
11484
11485static int G__RootEventData_rootcint_210_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11486{
11487 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffset((Int_t) G__int(libp->para[0])));
11488 return(1 || funcname || hash || result7 || libp) ;
11489}
11490
11491static int G__RootEventData_rootcint_210_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11492{
11493 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetElectron());
11494 return(1 || funcname || hash || result7 || libp) ;
11495}
11496
11497static int G__RootEventData_rootcint_210_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11498{
11499 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetMuon());
11500 return(1 || funcname || hash || result7 || libp) ;
11501}
11502
11503static int G__RootEventData_rootcint_210_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11504{
11505 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetPion());
11506 return(1 || funcname || hash || result7 || libp) ;
11507}
11508
11509static int G__RootEventData_rootcint_210_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11510{
11511 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetKaon());
11512 return(1 || funcname || hash || result7 || libp) ;
11513}
11514
11515static int G__RootEventData_rootcint_210_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11516{
11517 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetProton());
11518 return(1 || funcname || hash || result7 || libp) ;
11519}
11520
11521static int G__RootEventData_rootcint_210_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11522{
11523 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetAntiProton());
11524 return(1 || funcname || hash || result7 || libp) ;
11525}
11526
11527static int G__RootEventData_rootcint_210_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11528{
11529 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigma((Int_t) G__int(libp->para[0])));
11530 return(1 || funcname || hash || result7 || libp) ;
11531}
11532
11533static int G__RootEventData_rootcint_210_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11534{
11535 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaElectron());
11536 return(1 || funcname || hash || result7 || libp) ;
11537}
11538
11539static int G__RootEventData_rootcint_210_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11540{
11541 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaMuon());
11542 return(1 || funcname || hash || result7 || libp) ;
11543}
11544
11545static int G__RootEventData_rootcint_210_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11546{
11547 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaPion());
11548 return(1 || funcname || hash || result7 || libp) ;
11549}
11550
11551static int G__RootEventData_rootcint_210_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11552{
11553 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaKaon());
11554 return(1 || funcname || hash || result7 || libp) ;
11555}
11556
11557static int G__RootEventData_rootcint_210_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11558{
11559 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaProton());
11560 return(1 || funcname || hash || result7 || libp) ;
11561}
11562
11563static int G__RootEventData_rootcint_210_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11564{
11565 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaAntiProton());
11566 return(1 || funcname || hash || result7 || libp) ;
11567}
11568
11569static int G__RootEventData_rootcint_210_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11570{
11571 G__letint(result7, 105, (long) ((const TTofTrack*) G__getstructoffset())->quality());
11572 return(1 || funcname || hash || result7 || libp) ;
11573}
11574
11575static int G__RootEventData_rootcint_210_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11576{
11577 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->t0());
11578 return(1 || funcname || hash || result7 || libp) ;
11579}
11580
11581static int G__RootEventData_rootcint_210_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11582{
11583 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errt0());
11584 return(1 || funcname || hash || result7 || libp) ;
11585}
11586
11587static int G__RootEventData_rootcint_210_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11588{
11589 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errz());
11590 return(1 || funcname || hash || result7 || libp) ;
11591}
11592
11593static int G__RootEventData_rootcint_210_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11594{
11595 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->phi());
11596 return(1 || funcname || hash || result7 || libp) ;
11597}
11598
11599static int G__RootEventData_rootcint_210_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11600{
11601 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errphi());
11602 return(1 || funcname || hash || result7 || libp) ;
11603}
11604
11605static int G__RootEventData_rootcint_210_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11606{
11607 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->energy());
11608 return(1 || funcname || hash || result7 || libp) ;
11609}
11610
11611static int G__RootEventData_rootcint_210_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11612{
11613 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errenergy());
11614 return(1 || funcname || hash || result7 || libp) ;
11615}
11616
11617static int G__RootEventData_rootcint_210_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11618{
11619 G__letint(result7, 85, (long) TTofTrack::Class());
11620 return(1 || funcname || hash || result7 || libp) ;
11621}
11622
11623static int G__RootEventData_rootcint_210_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11624{
11625 G__letint(result7, 67, (long) TTofTrack::Class_Name());
11626 return(1 || funcname || hash || result7 || libp) ;
11627}
11628
11629static int G__RootEventData_rootcint_210_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11630{
11631 G__letint(result7, 115, (long) TTofTrack::Class_Version());
11632 return(1 || funcname || hash || result7 || libp) ;
11633}
11634
11635static int G__RootEventData_rootcint_210_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11636{
11637 TTofTrack::Dictionary();
11638 G__setnull(result7);
11639 return(1 || funcname || hash || result7 || libp) ;
11640}
11641
11642static int G__RootEventData_rootcint_210_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11643{
11644 ((TTofTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11645 G__setnull(result7);
11646 return(1 || funcname || hash || result7 || libp) ;
11647}
11648
11649static int G__RootEventData_rootcint_210_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11650{
11651 G__letint(result7, 67, (long) TTofTrack::DeclFileName());
11652 return(1 || funcname || hash || result7 || libp) ;
11653}
11654
11655static int G__RootEventData_rootcint_210_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11656{
11657 G__letint(result7, 105, (long) TTofTrack::ImplFileLine());
11658 return(1 || funcname || hash || result7 || libp) ;
11659}
11660
11661static int G__RootEventData_rootcint_210_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11662{
11663 G__letint(result7, 67, (long) TTofTrack::ImplFileName());
11664 return(1 || funcname || hash || result7 || libp) ;
11665}
11666
11667static int G__RootEventData_rootcint_210_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11668{
11669 G__letint(result7, 105, (long) TTofTrack::DeclFileLine());
11670 return(1 || funcname || hash || result7 || libp) ;
11671}
11672
11673// automatic copy constructor
11674static int G__RootEventData_rootcint_210_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11675
11676{
11677 TTofTrack* p;
11678 void* tmp = (void*) G__int(libp->para[0]);
11679 p = new TTofTrack(*(TTofTrack*) tmp);
11680 result7->obj.i = (long) p;
11681 result7->ref = (long) p;
11682 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack));
11683 return(1 || funcname || hash || result7 || libp) ;
11684}
11685
11686// automatic destructor
11687typedef TTofTrack G__TTTofTrack;
11688static int G__RootEventData_rootcint_210_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11689{
11690 char* gvp = (char*) G__getgvp();
11691 long soff = G__getstructoffset();
11692 int n = G__getaryconstruct();
11693 //
11694 //has_a_delete: 1
11695 //has_own_delete1arg: 0
11696 //has_own_delete2arg: 0
11697 //
11698 if (!soff) {
11699 return(1);
11700 }
11701 if (n) {
11702 if (gvp == (char*)G__PVOID) {
11703 delete[] (TTofTrack*) soff;
11704 } else {
11705 G__setgvp((long) G__PVOID);
11706 for (int i = n - 1; i >= 0; --i) {
11707 ((TTofTrack*) (soff+(sizeof(TTofTrack)*i)))->~G__TTTofTrack();
11708 }
11709 G__setgvp((long)gvp);
11710 }
11711 } else {
11712 if (gvp == (char*)G__PVOID) {
11713 delete (TTofTrack*) soff;
11714 } else {
11715 G__setgvp((long) G__PVOID);
11716 ((TTofTrack*) (soff))->~G__TTTofTrack();
11717 G__setgvp((long)gvp);
11718 }
11719 }
11720 G__setnull(result7);
11721 return(1 || funcname || hash || result7 || libp) ;
11722}
11723
11724// automatic assignment operator
11725static int G__RootEventData_rootcint_210_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11726{
11727 TTofTrack* dest = (TTofTrack*) G__getstructoffset();
11728 *dest = *(TTofTrack*) libp->para[0].ref;
11729 const TTofTrack& obj = *dest;
11730 result7->ref = (long) (&obj);
11731 result7->obj.i = (long) (&obj);
11732 return(1 || funcname || hash || result7 || libp) ;
11733}
11734
11735
11736/* TRecTofTrack */
11737static int G__RootEventData_rootcint_211_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11738{
11739 TRecTofTrack* p = NULL;
11740 char* gvp = (char*) G__getgvp();
11741 int n = G__getaryconstruct();
11742 if (n) {
11743 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11744 p = new TRecTofTrack[n];
11745 } else {
11746 p = new((void*) gvp) TRecTofTrack[n];
11747 }
11748 } else {
11749 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11750 p = new TRecTofTrack;
11751 } else {
11752 p = new((void*) gvp) TRecTofTrack;
11753 }
11754 }
11755 result7->obj.i = (long) p;
11756 result7->ref = (long) p;
11757 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack));
11758 return(1 || funcname || hash || result7 || libp) ;
11759}
11760
11761static int G__RootEventData_rootcint_211_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11762{
11763 G__letint(result7, 105, (long) ((const TRecTofTrack*) G__getstructoffset())->tofTrackID());
11764 return(1 || funcname || hash || result7 || libp) ;
11765}
11766
11767static int G__RootEventData_rootcint_211_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11768{
11769 G__letint(result7, 105, (long) ((const TRecTofTrack*) G__getstructoffset())->trackID());
11770 return(1 || funcname || hash || result7 || libp) ;
11771}
11772
11773static int G__RootEventData_rootcint_211_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11774{
11775 G__letint(result7, 105, (long) ((const TRecTofTrack*) G__getstructoffset())->tofID());
11776 return(1 || funcname || hash || result7 || libp) ;
11777}
11778
11779static int G__RootEventData_rootcint_211_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11780{
11781 G__letint(result7, 104, (long) ((const TRecTofTrack*) G__getstructoffset())->status());
11782 return(1 || funcname || hash || result7 || libp) ;
11783}
11784
11785static int G__RootEventData_rootcint_211_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11786{
11787 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->path());
11788 return(1 || funcname || hash || result7 || libp) ;
11789}
11790
11791static int G__RootEventData_rootcint_211_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11792{
11793 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->zrhit());
11794 return(1 || funcname || hash || result7 || libp) ;
11795}
11796
11797static int G__RootEventData_rootcint_211_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11798{
11799 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->ph());
11800 return(1 || funcname || hash || result7 || libp) ;
11801}
11802
11803static int G__RootEventData_rootcint_211_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11804{
11805 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->tof());
11806 return(1 || funcname || hash || result7 || libp) ;
11807}
11808
11809static int G__RootEventData_rootcint_211_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11810{
11811 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errtof());
11812 return(1 || funcname || hash || result7 || libp) ;
11813}
11814
11815static int G__RootEventData_rootcint_211_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11816{
11817 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->beta());
11818 return(1 || funcname || hash || result7 || libp) ;
11819}
11820
11821static int G__RootEventData_rootcint_211_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11822{
11823 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texp((Int_t) G__int(libp->para[0])));
11824 return(1 || funcname || hash || result7 || libp) ;
11825}
11826
11827static int G__RootEventData_rootcint_211_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11828{
11829 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpElectron());
11830 return(1 || funcname || hash || result7 || libp) ;
11831}
11832
11833static int G__RootEventData_rootcint_211_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11834{
11835 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpMuon());
11836 return(1 || funcname || hash || result7 || libp) ;
11837}
11838
11839static int G__RootEventData_rootcint_211_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11840{
11841 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpPion());
11842 return(1 || funcname || hash || result7 || libp) ;
11843}
11844
11845static int G__RootEventData_rootcint_211_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11846{
11847 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpKaon());
11848 return(1 || funcname || hash || result7 || libp) ;
11849}
11850
11851static int G__RootEventData_rootcint_211_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11852{
11853 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpProton());
11854 return(1 || funcname || hash || result7 || libp) ;
11855}
11856
11857static int G__RootEventData_rootcint_211_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11858{
11859 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffset((Int_t) G__int(libp->para[0])));
11860 return(1 || funcname || hash || result7 || libp) ;
11861}
11862
11863static int G__RootEventData_rootcint_211_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11864{
11865 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetElectron());
11866 return(1 || funcname || hash || result7 || libp) ;
11867}
11868
11869static int G__RootEventData_rootcint_211_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11870{
11871 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetMuon());
11872 return(1 || funcname || hash || result7 || libp) ;
11873}
11874
11875static int G__RootEventData_rootcint_211_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11876{
11877 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetPion());
11878 return(1 || funcname || hash || result7 || libp) ;
11879}
11880
11881static int G__RootEventData_rootcint_211_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11882{
11883 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetKaon());
11884 return(1 || funcname || hash || result7 || libp) ;
11885}
11886
11887static int G__RootEventData_rootcint_211_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11888{
11889 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetProton());
11890 return(1 || funcname || hash || result7 || libp) ;
11891}
11892
11893static int G__RootEventData_rootcint_211_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11894{
11895 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetAntiProton());
11896 return(1 || funcname || hash || result7 || libp) ;
11897}
11898
11899static int G__RootEventData_rootcint_211_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11900{
11901 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigma((Int_t) G__int(libp->para[0])));
11902 return(1 || funcname || hash || result7 || libp) ;
11903}
11904
11905static int G__RootEventData_rootcint_211_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11906{
11907 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaElectron());
11908 return(1 || funcname || hash || result7 || libp) ;
11909}
11910
11911static int G__RootEventData_rootcint_211_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11912{
11913 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaMuon());
11914 return(1 || funcname || hash || result7 || libp) ;
11915}
11916
11917static int G__RootEventData_rootcint_211_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11918{
11919 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaPion());
11920 return(1 || funcname || hash || result7 || libp) ;
11921}
11922
11923static int G__RootEventData_rootcint_211_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11924{
11925 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaKaon());
11926 return(1 || funcname || hash || result7 || libp) ;
11927}
11928
11929static int G__RootEventData_rootcint_211_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11930{
11931 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaProton());
11932 return(1 || funcname || hash || result7 || libp) ;
11933}
11934
11935static int G__RootEventData_rootcint_211_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11936{
11937 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaAntiProton());
11938 return(1 || funcname || hash || result7 || libp) ;
11939}
11940
11941static int G__RootEventData_rootcint_211_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11942{
11943 G__letint(result7, 105, (long) ((const TRecTofTrack*) G__getstructoffset())->quality());
11944 return(1 || funcname || hash || result7 || libp) ;
11945}
11946
11947static int G__RootEventData_rootcint_211_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11948{
11949 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->t0());
11950 return(1 || funcname || hash || result7 || libp) ;
11951}
11952
11953static int G__RootEventData_rootcint_211_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11954{
11955 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errt0());
11956 return(1 || funcname || hash || result7 || libp) ;
11957}
11958
11959static int G__RootEventData_rootcint_211_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11960{
11961 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errz());
11962 return(1 || funcname || hash || result7 || libp) ;
11963}
11964
11965static int G__RootEventData_rootcint_211_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11966{
11967 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->phi());
11968 return(1 || funcname || hash || result7 || libp) ;
11969}
11970
11971static int G__RootEventData_rootcint_211_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11972{
11973 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errphi());
11974 return(1 || funcname || hash || result7 || libp) ;
11975}
11976
11977static int G__RootEventData_rootcint_211_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11978{
11979 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->energy());
11980 return(1 || funcname || hash || result7 || libp) ;
11981}
11982
11983static int G__RootEventData_rootcint_211_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11984{
11985 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errenergy());
11986 return(1 || funcname || hash || result7 || libp) ;
11987}
11988
11989static int G__RootEventData_rootcint_211_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11990{
11991 ((TRecTofTrack*) G__getstructoffset())->setTofTrackID((Int_t) G__int(libp->para[0]));
11992 G__setnull(result7);
11993 return(1 || funcname || hash || result7 || libp) ;
11994}
11995
11996static int G__RootEventData_rootcint_211_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11997{
11998 ((TRecTofTrack*) G__getstructoffset())->setTrackID((Int_t) G__int(libp->para[0]));
11999 G__setnull(result7);
12000 return(1 || funcname || hash || result7 || libp) ;
12001}
12002
12003static int G__RootEventData_rootcint_211_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12004{
12005 ((TRecTofTrack*) G__getstructoffset())->setTofID((Int_t) G__int(libp->para[0]));
12006 G__setnull(result7);
12007 return(1 || funcname || hash || result7 || libp) ;
12008}
12009
12010static int G__RootEventData_rootcint_211_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12011{
12012 ((TRecTofTrack*) G__getstructoffset())->setStatus((UInt_t) G__int(libp->para[0]));
12013 G__setnull(result7);
12014 return(1 || funcname || hash || result7 || libp) ;
12015}
12016
12017static int G__RootEventData_rootcint_211_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12018{
12019 ((TRecTofTrack*) G__getstructoffset())->setPath((Double_t) G__double(libp->para[0]));
12020 G__setnull(result7);
12021 return(1 || funcname || hash || result7 || libp) ;
12022}
12023
12024static int G__RootEventData_rootcint_211_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12025{
12026 ((TRecTofTrack*) G__getstructoffset())->setZrHit((Double_t) G__double(libp->para[0]));
12027 G__setnull(result7);
12028 return(1 || funcname || hash || result7 || libp) ;
12029}
12030
12031static int G__RootEventData_rootcint_211_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12032{
12033 ((TRecTofTrack*) G__getstructoffset())->setPh((Double_t) G__double(libp->para[0]));
12034 G__setnull(result7);
12035 return(1 || funcname || hash || result7 || libp) ;
12036}
12037
12038static int G__RootEventData_rootcint_211_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12039{
12040 ((TRecTofTrack*) G__getstructoffset())->setTof((Double_t) G__double(libp->para[0]));
12041 G__setnull(result7);
12042 return(1 || funcname || hash || result7 || libp) ;
12043}
12044
12045static int G__RootEventData_rootcint_211_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12046{
12047 ((TRecTofTrack*) G__getstructoffset())->setErrTof((Double_t) G__double(libp->para[0]));
12048 G__setnull(result7);
12049 return(1 || funcname || hash || result7 || libp) ;
12050}
12051
12052static int G__RootEventData_rootcint_211_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12053{
12054 ((TRecTofTrack*) G__getstructoffset())->setBeta((Double_t) G__double(libp->para[0]));
12055 G__setnull(result7);
12056 return(1 || funcname || hash || result7 || libp) ;
12057}
12058
12059static int G__RootEventData_rootcint_211_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12060{
12061 ((TRecTofTrack*) G__getstructoffset())->setTexp((Double_t*) G__int(libp->para[0]));
12062 G__setnull(result7);
12063 return(1 || funcname || hash || result7 || libp) ;
12064}
12065
12066static int G__RootEventData_rootcint_211_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12067{
12068 ((TRecTofTrack*) G__getstructoffset())->setTexpElectron((Double_t) G__double(libp->para[0]));
12069 G__setnull(result7);
12070 return(1 || funcname || hash || result7 || libp) ;
12071}
12072
12073static int G__RootEventData_rootcint_211_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12074{
12075 ((TRecTofTrack*) G__getstructoffset())->setTexpMuon((Double_t) G__double(libp->para[0]));
12076 G__setnull(result7);
12077 return(1 || funcname || hash || result7 || libp) ;
12078}
12079
12080static int G__RootEventData_rootcint_211_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12081{
12082 ((TRecTofTrack*) G__getstructoffset())->setTexpPion((Double_t) G__double(libp->para[0]));
12083 G__setnull(result7);
12084 return(1 || funcname || hash || result7 || libp) ;
12085}
12086
12087static int G__RootEventData_rootcint_211_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12088{
12089 ((TRecTofTrack*) G__getstructoffset())->setTexpKaon((Double_t) G__double(libp->para[0]));
12090 G__setnull(result7);
12091 return(1 || funcname || hash || result7 || libp) ;
12092}
12093
12094static int G__RootEventData_rootcint_211_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12095{
12096 ((TRecTofTrack*) G__getstructoffset())->setTexpProton((Double_t) G__double(libp->para[0]));
12097 G__setnull(result7);
12098 return(1 || funcname || hash || result7 || libp) ;
12099}
12100
12101static int G__RootEventData_rootcint_211_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12102{
12103 ((TRecTofTrack*) G__getstructoffset())->setToffset((Double_t*) G__int(libp->para[0]));
12104 G__setnull(result7);
12105 return(1 || funcname || hash || result7 || libp) ;
12106}
12107
12108static int G__RootEventData_rootcint_211_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12109{
12110 ((TRecTofTrack*) G__getstructoffset())->setToffsetElectron((Double_t) G__double(libp->para[0]));
12111 G__setnull(result7);
12112 return(1 || funcname || hash || result7 || libp) ;
12113}
12114
12115static int G__RootEventData_rootcint_211_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12116{
12117 ((TRecTofTrack*) G__getstructoffset())->setToffsetMuon((Double_t) G__double(libp->para[0]));
12118 G__setnull(result7);
12119 return(1 || funcname || hash || result7 || libp) ;
12120}
12121
12122static int G__RootEventData_rootcint_211_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12123{
12124 ((TRecTofTrack*) G__getstructoffset())->setToffsetPion((Double_t) G__double(libp->para[0]));
12125 G__setnull(result7);
12126 return(1 || funcname || hash || result7 || libp) ;
12127}
12128
12129static int G__RootEventData_rootcint_211_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12130{
12131 ((TRecTofTrack*) G__getstructoffset())->setToffsetKaon((Double_t) G__double(libp->para[0]));
12132 G__setnull(result7);
12133 return(1 || funcname || hash || result7 || libp) ;
12134}
12135
12136static int G__RootEventData_rootcint_211_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12137{
12138 ((TRecTofTrack*) G__getstructoffset())->setToffsetProton((Double_t) G__double(libp->para[0]));
12139 G__setnull(result7);
12140 return(1 || funcname || hash || result7 || libp) ;
12141}
12142
12143static int G__RootEventData_rootcint_211_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12144{
12145 ((TRecTofTrack*) G__getstructoffset())->setToffsetAntiProton((Double_t) G__double(libp->para[0]));
12146 G__setnull(result7);
12147 return(1 || funcname || hash || result7 || libp) ;
12148}
12149
12150static int G__RootEventData_rootcint_211_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12151{
12152 ((TRecTofTrack*) G__getstructoffset())->setSigma((Double_t*) G__int(libp->para[0]));
12153 G__setnull(result7);
12154 return(1 || funcname || hash || result7 || libp) ;
12155}
12156
12157static int G__RootEventData_rootcint_211_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12158{
12159 ((TRecTofTrack*) G__getstructoffset())->setSigmaElectron((Double_t) G__double(libp->para[0]));
12160 G__setnull(result7);
12161 return(1 || funcname || hash || result7 || libp) ;
12162}
12163
12164static int G__RootEventData_rootcint_211_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12165{
12166 ((TRecTofTrack*) G__getstructoffset())->setSigmaMuon((Double_t) G__double(libp->para[0]));
12167 G__setnull(result7);
12168 return(1 || funcname || hash || result7 || libp) ;
12169}
12170
12171static int G__RootEventData_rootcint_211_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12172{
12173 ((TRecTofTrack*) G__getstructoffset())->setSigmaPion((Double_t) G__double(libp->para[0]));
12174 G__setnull(result7);
12175 return(1 || funcname || hash || result7 || libp) ;
12176}
12177
12178static int G__RootEventData_rootcint_211_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12179{
12180 ((TRecTofTrack*) G__getstructoffset())->setSigmaKaon((Double_t) G__double(libp->para[0]));
12181 G__setnull(result7);
12182 return(1 || funcname || hash || result7 || libp) ;
12183}
12184
12185static int G__RootEventData_rootcint_211_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12186{
12187 ((TRecTofTrack*) G__getstructoffset())->setSigmaProton((Double_t) G__double(libp->para[0]));
12188 G__setnull(result7);
12189 return(1 || funcname || hash || result7 || libp) ;
12190}
12191
12192static int G__RootEventData_rootcint_211_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12193{
12194 ((TRecTofTrack*) G__getstructoffset())->setSigmaAntiProton((Double_t) G__double(libp->para[0]));
12195 G__setnull(result7);
12196 return(1 || funcname || hash || result7 || libp) ;
12197}
12198
12199static int G__RootEventData_rootcint_211_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12200{
12201 ((TRecTofTrack*) G__getstructoffset())->setQuality((Int_t) G__int(libp->para[0]));
12202 G__setnull(result7);
12203 return(1 || funcname || hash || result7 || libp) ;
12204}
12205
12206static int G__RootEventData_rootcint_211_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12207{
12208 ((TRecTofTrack*) G__getstructoffset())->setT0((Double_t) G__double(libp->para[0]));
12209 G__setnull(result7);
12210 return(1 || funcname || hash || result7 || libp) ;
12211}
12212
12213static int G__RootEventData_rootcint_211_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12214{
12215 ((TRecTofTrack*) G__getstructoffset())->setErrT0((Double_t) G__double(libp->para[0]));
12216 G__setnull(result7);
12217 return(1 || funcname || hash || result7 || libp) ;
12218}
12219
12220static int G__RootEventData_rootcint_211_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12221{
12222 ((TRecTofTrack*) G__getstructoffset())->setErrZ((Double_t) G__double(libp->para[0]));
12223 G__setnull(result7);
12224 return(1 || funcname || hash || result7 || libp) ;
12225}
12226
12227static int G__RootEventData_rootcint_211_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12228{
12229 ((TRecTofTrack*) G__getstructoffset())->setPhi((Double_t) G__double(libp->para[0]));
12230 G__setnull(result7);
12231 return(1 || funcname || hash || result7 || libp) ;
12232}
12233
12234static int G__RootEventData_rootcint_211_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12235{
12236 ((TRecTofTrack*) G__getstructoffset())->setErrPhi((Double_t) G__double(libp->para[0]));
12237 G__setnull(result7);
12238 return(1 || funcname || hash || result7 || libp) ;
12239}
12240
12241static int G__RootEventData_rootcint_211_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12242{
12243 ((TRecTofTrack*) G__getstructoffset())->setEnergy((Double_t) G__double(libp->para[0]));
12244 G__setnull(result7);
12245 return(1 || funcname || hash || result7 || libp) ;
12246}
12247
12248static int G__RootEventData_rootcint_211_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12249{
12250 ((TRecTofTrack*) G__getstructoffset())->setErrEnergy((Double_t) G__double(libp->para[0]));
12251 G__setnull(result7);
12252 return(1 || funcname || hash || result7 || libp) ;
12253}
12254
12255static int G__RootEventData_rootcint_211_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12256{
12257 ((TRecTofTrack*) G__getstructoffset())->setTRecTofTrack((TRecTofTrack*) G__int(libp->para[0]));
12258 G__setnull(result7);
12259 return(1 || funcname || hash || result7 || libp) ;
12260}
12261
12262static int G__RootEventData_rootcint_211_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12263{
12264 G__letint(result7, 85, (long) TRecTofTrack::Class());
12265 return(1 || funcname || hash || result7 || libp) ;
12266}
12267
12268static int G__RootEventData_rootcint_211_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12269{
12270 G__letint(result7, 67, (long) TRecTofTrack::Class_Name());
12271 return(1 || funcname || hash || result7 || libp) ;
12272}
12273
12274static int G__RootEventData_rootcint_211_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12275{
12276 G__letint(result7, 115, (long) TRecTofTrack::Class_Version());
12277 return(1 || funcname || hash || result7 || libp) ;
12278}
12279
12280static int G__RootEventData_rootcint_211_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12281{
12282 TRecTofTrack::Dictionary();
12283 G__setnull(result7);
12284 return(1 || funcname || hash || result7 || libp) ;
12285}
12286
12287static int G__RootEventData_rootcint_211_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12288{
12289 ((TRecTofTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12290 G__setnull(result7);
12291 return(1 || funcname || hash || result7 || libp) ;
12292}
12293
12294static int G__RootEventData_rootcint_211_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12295{
12296 G__letint(result7, 67, (long) TRecTofTrack::DeclFileName());
12297 return(1 || funcname || hash || result7 || libp) ;
12298}
12299
12300static int G__RootEventData_rootcint_211_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12301{
12302 G__letint(result7, 105, (long) TRecTofTrack::ImplFileLine());
12303 return(1 || funcname || hash || result7 || libp) ;
12304}
12305
12306static int G__RootEventData_rootcint_211_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12307{
12308 G__letint(result7, 67, (long) TRecTofTrack::ImplFileName());
12309 return(1 || funcname || hash || result7 || libp) ;
12310}
12311
12312static int G__RootEventData_rootcint_211_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12313{
12314 G__letint(result7, 105, (long) TRecTofTrack::DeclFileLine());
12315 return(1 || funcname || hash || result7 || libp) ;
12316}
12317
12318// automatic copy constructor
12319static int G__RootEventData_rootcint_211_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12320
12321{
12322 TRecTofTrack* p;
12323 void* tmp = (void*) G__int(libp->para[0]);
12324 p = new TRecTofTrack(*(TRecTofTrack*) tmp);
12325 result7->obj.i = (long) p;
12326 result7->ref = (long) p;
12327 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack));
12328 return(1 || funcname || hash || result7 || libp) ;
12329}
12330
12331// automatic destructor
12332typedef TRecTofTrack G__TTRecTofTrack;
12333static int G__RootEventData_rootcint_211_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12334{
12335 char* gvp = (char*) G__getgvp();
12336 long soff = G__getstructoffset();
12337 int n = G__getaryconstruct();
12338 //
12339 //has_a_delete: 1
12340 //has_own_delete1arg: 0
12341 //has_own_delete2arg: 0
12342 //
12343 if (!soff) {
12344 return(1);
12345 }
12346 if (n) {
12347 if (gvp == (char*)G__PVOID) {
12348 delete[] (TRecTofTrack*) soff;
12349 } else {
12350 G__setgvp((long) G__PVOID);
12351 for (int i = n - 1; i >= 0; --i) {
12352 ((TRecTofTrack*) (soff+(sizeof(TRecTofTrack)*i)))->~G__TTRecTofTrack();
12353 }
12354 G__setgvp((long)gvp);
12355 }
12356 } else {
12357 if (gvp == (char*)G__PVOID) {
12358 delete (TRecTofTrack*) soff;
12359 } else {
12360 G__setgvp((long) G__PVOID);
12361 ((TRecTofTrack*) (soff))->~G__TTRecTofTrack();
12362 G__setgvp((long)gvp);
12363 }
12364 }
12365 G__setnull(result7);
12366 return(1 || funcname || hash || result7 || libp) ;
12367}
12368
12369// automatic assignment operator
12370static int G__RootEventData_rootcint_211_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12371{
12372 TRecTofTrack* dest = (TRecTofTrack*) G__getstructoffset();
12373 *dest = *(TRecTofTrack*) libp->para[0].ref;
12374 const TRecTofTrack& obj = *dest;
12375 result7->ref = (long) (&obj);
12376 result7->obj.i = (long) (&obj);
12377 return(1 || funcname || hash || result7 || libp) ;
12378}
12379
12380
12381/* TRecEmcHit */
12382static int G__RootEventData_rootcint_212_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12383{
12384 TRecEmcHit* p = NULL;
12385 char* gvp = (char*) G__getgvp();
12386 int n = G__getaryconstruct();
12387 if (n) {
12388 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12389 p = new TRecEmcHit[n];
12390 } else {
12391 p = new((void*) gvp) TRecEmcHit[n];
12392 }
12393 } else {
12394 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12395 p = new TRecEmcHit;
12396 } else {
12397 p = new((void*) gvp) TRecEmcHit;
12398 }
12399 }
12400 result7->obj.i = (long) p;
12401 result7->ref = (long) p;
12402 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit));
12403 return(1 || funcname || hash || result7 || libp) ;
12404}
12405
12406static int G__RootEventData_rootcint_212_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12407{
12408 G__letint(result7, 105, (long) ((const TRecEmcHit*) G__getstructoffset())->cellId());
12409 return(1 || funcname || hash || result7 || libp) ;
12410}
12411
12412static int G__RootEventData_rootcint_212_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12413{
12414 G__letdouble(result7, 100, (double) ((const TRecEmcHit*) G__getstructoffset())->energy());
12415 return(1 || funcname || hash || result7 || libp) ;
12416}
12417
12418static int G__RootEventData_rootcint_212_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12419{
12420 G__letdouble(result7, 100, (double) ((const TRecEmcHit*) G__getstructoffset())->time());
12421 return(1 || funcname || hash || result7 || libp) ;
12422}
12423
12424static int G__RootEventData_rootcint_212_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12425{
12426 ((TRecEmcHit*) G__getstructoffset())->setCellId((const Int_t) G__int(libp->para[0]));
12427 G__setnull(result7);
12428 return(1 || funcname || hash || result7 || libp) ;
12429}
12430
12431static int G__RootEventData_rootcint_212_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12432{
12433 ((TRecEmcHit*) G__getstructoffset())->setEnergy((const Double_t) G__double(libp->para[0]));
12434 G__setnull(result7);
12435 return(1 || funcname || hash || result7 || libp) ;
12436}
12437
12438static int G__RootEventData_rootcint_212_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12439{
12440 ((TRecEmcHit*) G__getstructoffset())->setTime((const Double_t) G__double(libp->para[0]));
12441 G__setnull(result7);
12442 return(1 || funcname || hash || result7 || libp) ;
12443}
12444
12445static int G__RootEventData_rootcint_212_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12446{
12447 G__letint(result7, 85, (long) TRecEmcHit::Class());
12448 return(1 || funcname || hash || result7 || libp) ;
12449}
12450
12451static int G__RootEventData_rootcint_212_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12452{
12453 G__letint(result7, 67, (long) TRecEmcHit::Class_Name());
12454 return(1 || funcname || hash || result7 || libp) ;
12455}
12456
12457static int G__RootEventData_rootcint_212_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12458{
12459 G__letint(result7, 115, (long) TRecEmcHit::Class_Version());
12460 return(1 || funcname || hash || result7 || libp) ;
12461}
12462
12463static int G__RootEventData_rootcint_212_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12464{
12465 TRecEmcHit::Dictionary();
12466 G__setnull(result7);
12467 return(1 || funcname || hash || result7 || libp) ;
12468}
12469
12470static int G__RootEventData_rootcint_212_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12471{
12472 ((TRecEmcHit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12473 G__setnull(result7);
12474 return(1 || funcname || hash || result7 || libp) ;
12475}
12476
12477static int G__RootEventData_rootcint_212_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12478{
12479 G__letint(result7, 67, (long) TRecEmcHit::DeclFileName());
12480 return(1 || funcname || hash || result7 || libp) ;
12481}
12482
12483static int G__RootEventData_rootcint_212_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12484{
12485 G__letint(result7, 105, (long) TRecEmcHit::ImplFileLine());
12486 return(1 || funcname || hash || result7 || libp) ;
12487}
12488
12489static int G__RootEventData_rootcint_212_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12490{
12491 G__letint(result7, 67, (long) TRecEmcHit::ImplFileName());
12492 return(1 || funcname || hash || result7 || libp) ;
12493}
12494
12495static int G__RootEventData_rootcint_212_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12496{
12497 G__letint(result7, 105, (long) TRecEmcHit::DeclFileLine());
12498 return(1 || funcname || hash || result7 || libp) ;
12499}
12500
12501// automatic copy constructor
12502static int G__RootEventData_rootcint_212_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12503
12504{
12505 TRecEmcHit* p;
12506 void* tmp = (void*) G__int(libp->para[0]);
12507 p = new TRecEmcHit(*(TRecEmcHit*) tmp);
12508 result7->obj.i = (long) p;
12509 result7->ref = (long) p;
12510 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit));
12511 return(1 || funcname || hash || result7 || libp) ;
12512}
12513
12514// automatic destructor
12515typedef TRecEmcHit G__TTRecEmcHit;
12516static int G__RootEventData_rootcint_212_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12517{
12518 char* gvp = (char*) G__getgvp();
12519 long soff = G__getstructoffset();
12520 int n = G__getaryconstruct();
12521 //
12522 //has_a_delete: 1
12523 //has_own_delete1arg: 0
12524 //has_own_delete2arg: 0
12525 //
12526 if (!soff) {
12527 return(1);
12528 }
12529 if (n) {
12530 if (gvp == (char*)G__PVOID) {
12531 delete[] (TRecEmcHit*) soff;
12532 } else {
12533 G__setgvp((long) G__PVOID);
12534 for (int i = n - 1; i >= 0; --i) {
12535 ((TRecEmcHit*) (soff+(sizeof(TRecEmcHit)*i)))->~G__TTRecEmcHit();
12536 }
12537 G__setgvp((long)gvp);
12538 }
12539 } else {
12540 if (gvp == (char*)G__PVOID) {
12541 delete (TRecEmcHit*) soff;
12542 } else {
12543 G__setgvp((long) G__PVOID);
12544 ((TRecEmcHit*) (soff))->~G__TTRecEmcHit();
12545 G__setgvp((long)gvp);
12546 }
12547 }
12548 G__setnull(result7);
12549 return(1 || funcname || hash || result7 || libp) ;
12550}
12551
12552// automatic assignment operator
12553static int G__RootEventData_rootcint_212_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12554{
12555 TRecEmcHit* dest = (TRecEmcHit*) G__getstructoffset();
12556 *dest = *(TRecEmcHit*) libp->para[0].ref;
12557 const TRecEmcHit& obj = *dest;
12558 result7->ref = (long) (&obj);
12559 result7->obj.i = (long) (&obj);
12560 return(1 || funcname || hash || result7 || libp) ;
12561}
12562
12563
12564/* TRecEmcCluster */
12565static int G__RootEventData_rootcint_213_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12566{
12567 TRecEmcCluster* p = NULL;
12568 char* gvp = (char*) G__getgvp();
12569 int n = G__getaryconstruct();
12570 if (n) {
12571 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12572 p = new TRecEmcCluster[n];
12573 } else {
12574 p = new((void*) gvp) TRecEmcCluster[n];
12575 }
12576 } else {
12577 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12578 p = new TRecEmcCluster;
12579 } else {
12580 p = new((void*) gvp) TRecEmcCluster;
12581 }
12582 }
12583 result7->obj.i = (long) p;
12584 result7->ref = (long) p;
12585 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster));
12586 return(1 || funcname || hash || result7 || libp) ;
12587}
12588
12589static int G__RootEventData_rootcint_213_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12590{
12591 G__letint(result7, 105, (long) ((const TRecEmcCluster*) G__getstructoffset())->clusterId());
12592 return(1 || funcname || hash || result7 || libp) ;
12593}
12594
12595static int G__RootEventData_rootcint_213_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12596{
12597 {
12598 const vector<Int_t>* pobj;
12599 const vector<Int_t> xobj = ((const TRecEmcCluster*) G__getstructoffset())->vecHits();
12600 pobj = new vector<Int_t>(xobj);
12601 result7->obj.i = (long) ((void*) pobj);
12602 result7->ref = result7->obj.i;
12603 G__store_tempobject(*result7);
12604 }
12605 return(1 || funcname || hash || result7 || libp) ;
12606}
12607
12608static int G__RootEventData_rootcint_213_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12609{
12610 {
12611 const vector<Int_t>* pobj;
12612 const vector<Int_t> xobj = ((const TRecEmcCluster*) G__getstructoffset())->vecSeeds();
12613 pobj = new vector<Int_t>(xobj);
12614 result7->obj.i = (long) ((void*) pobj);
12615 result7->ref = result7->obj.i;
12616 G__store_tempobject(*result7);
12617 }
12618 return(1 || funcname || hash || result7 || libp) ;
12619}
12620
12621static int G__RootEventData_rootcint_213_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12622{
12623 {
12624 const vector<Int_t>* pobj;
12625 const vector<Int_t> xobj = ((const TRecEmcCluster*) G__getstructoffset())->vecShowers();
12626 pobj = new vector<Int_t>(xobj);
12627 result7->obj.i = (long) ((void*) pobj);
12628 result7->ref = result7->obj.i;
12629 G__store_tempobject(*result7);
12630 }
12631 return(1 || funcname || hash || result7 || libp) ;
12632}
12633
12634static int G__RootEventData_rootcint_213_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12635{
12636 ((TRecEmcCluster*) G__getstructoffset())->setClusterId((const Int_t) G__int(libp->para[0]));
12637 G__setnull(result7);
12638 return(1 || funcname || hash || result7 || libp) ;
12639}
12640
12641static int G__RootEventData_rootcint_213_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12642{
12643 ((TRecEmcCluster*) G__getstructoffset())->setVecHits(*(vector<Int_t>*) libp->para[0].ref);
12644 G__setnull(result7);
12645 return(1 || funcname || hash || result7 || libp) ;
12646}
12647
12648static int G__RootEventData_rootcint_213_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12649{
12650 ((TRecEmcCluster*) G__getstructoffset())->setVecSeeds(*(vector<Int_t>*) libp->para[0].ref);
12651 G__setnull(result7);
12652 return(1 || funcname || hash || result7 || libp) ;
12653}
12654
12655static int G__RootEventData_rootcint_213_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12656{
12657 ((TRecEmcCluster*) G__getstructoffset())->setVecShowers(*(vector<Int_t>*) libp->para[0].ref);
12658 G__setnull(result7);
12659 return(1 || funcname || hash || result7 || libp) ;
12660}
12661
12662static int G__RootEventData_rootcint_213_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12663{
12664 G__letint(result7, 85, (long) TRecEmcCluster::Class());
12665 return(1 || funcname || hash || result7 || libp) ;
12666}
12667
12668static int G__RootEventData_rootcint_213_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12669{
12670 G__letint(result7, 67, (long) TRecEmcCluster::Class_Name());
12671 return(1 || funcname || hash || result7 || libp) ;
12672}
12673
12674static int G__RootEventData_rootcint_213_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12675{
12676 G__letint(result7, 115, (long) TRecEmcCluster::Class_Version());
12677 return(1 || funcname || hash || result7 || libp) ;
12678}
12679
12680static int G__RootEventData_rootcint_213_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12681{
12682 TRecEmcCluster::Dictionary();
12683 G__setnull(result7);
12684 return(1 || funcname || hash || result7 || libp) ;
12685}
12686
12687static int G__RootEventData_rootcint_213_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12688{
12689 ((TRecEmcCluster*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12690 G__setnull(result7);
12691 return(1 || funcname || hash || result7 || libp) ;
12692}
12693
12694static int G__RootEventData_rootcint_213_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12695{
12696 G__letint(result7, 67, (long) TRecEmcCluster::DeclFileName());
12697 return(1 || funcname || hash || result7 || libp) ;
12698}
12699
12700static int G__RootEventData_rootcint_213_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12701{
12702 G__letint(result7, 105, (long) TRecEmcCluster::ImplFileLine());
12703 return(1 || funcname || hash || result7 || libp) ;
12704}
12705
12706static int G__RootEventData_rootcint_213_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12707{
12708 G__letint(result7, 67, (long) TRecEmcCluster::ImplFileName());
12709 return(1 || funcname || hash || result7 || libp) ;
12710}
12711
12712static int G__RootEventData_rootcint_213_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12713{
12714 G__letint(result7, 105, (long) TRecEmcCluster::DeclFileLine());
12715 return(1 || funcname || hash || result7 || libp) ;
12716}
12717
12718// automatic copy constructor
12719static int G__RootEventData_rootcint_213_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12720
12721{
12722 TRecEmcCluster* p;
12723 void* tmp = (void*) G__int(libp->para[0]);
12724 p = new TRecEmcCluster(*(TRecEmcCluster*) tmp);
12725 result7->obj.i = (long) p;
12726 result7->ref = (long) p;
12727 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster));
12728 return(1 || funcname || hash || result7 || libp) ;
12729}
12730
12731// automatic destructor
12732typedef TRecEmcCluster G__TTRecEmcCluster;
12733static int G__RootEventData_rootcint_213_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12734{
12735 char* gvp = (char*) G__getgvp();
12736 long soff = G__getstructoffset();
12737 int n = G__getaryconstruct();
12738 //
12739 //has_a_delete: 1
12740 //has_own_delete1arg: 0
12741 //has_own_delete2arg: 0
12742 //
12743 if (!soff) {
12744 return(1);
12745 }
12746 if (n) {
12747 if (gvp == (char*)G__PVOID) {
12748 delete[] (TRecEmcCluster*) soff;
12749 } else {
12750 G__setgvp((long) G__PVOID);
12751 for (int i = n - 1; i >= 0; --i) {
12752 ((TRecEmcCluster*) (soff+(sizeof(TRecEmcCluster)*i)))->~G__TTRecEmcCluster();
12753 }
12754 G__setgvp((long)gvp);
12755 }
12756 } else {
12757 if (gvp == (char*)G__PVOID) {
12758 delete (TRecEmcCluster*) soff;
12759 } else {
12760 G__setgvp((long) G__PVOID);
12761 ((TRecEmcCluster*) (soff))->~G__TTRecEmcCluster();
12762 G__setgvp((long)gvp);
12763 }
12764 }
12765 G__setnull(result7);
12766 return(1 || funcname || hash || result7 || libp) ;
12767}
12768
12769// automatic assignment operator
12770static int G__RootEventData_rootcint_213_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12771{
12772 TRecEmcCluster* dest = (TRecEmcCluster*) G__getstructoffset();
12773 *dest = *(TRecEmcCluster*) libp->para[0].ref;
12774 const TRecEmcCluster& obj = *dest;
12775 result7->ref = (long) (&obj);
12776 result7->obj.i = (long) (&obj);
12777 return(1 || funcname || hash || result7 || libp) ;
12778}
12779
12780
12781/* TRecEmcShower */
12782static int G__RootEventData_rootcint_449_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12783{
12784 TRecEmcShower* p = NULL;
12785 char* gvp = (char*) G__getgvp();
12786 int n = G__getaryconstruct();
12787 if (n) {
12788 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12789 p = new TRecEmcShower[n];
12790 } else {
12791 p = new((void*) gvp) TRecEmcShower[n];
12792 }
12793 } else {
12794 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12795 p = new TRecEmcShower;
12796 } else {
12797 p = new((void*) gvp) TRecEmcShower;
12798 }
12799 }
12800 result7->obj.i = (long) p;
12801 result7->ref = (long) p;
12802 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower));
12803 return(1 || funcname || hash || result7 || libp) ;
12804}
12805
12806static int G__RootEventData_rootcint_449_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12807{
12808 G__letint(result7, 105, (long) ((const TRecEmcShower*) G__getstructoffset())->trackId());
12809 return(1 || funcname || hash || result7 || libp) ;
12810}
12811
12812static int G__RootEventData_rootcint_449_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12813{
12814 G__letint(result7, 105, (long) ((const TRecEmcShower*) G__getstructoffset())->numHits());
12815 return(1 || funcname || hash || result7 || libp) ;
12816}
12817
12818static int G__RootEventData_rootcint_449_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12819{
12820 G__letint(result7, 105, (long) ((const TRecEmcShower*) G__getstructoffset())->status());
12821 return(1 || funcname || hash || result7 || libp) ;
12822}
12823
12824static int G__RootEventData_rootcint_449_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12825{
12826 G__letint(result7, 105, (long) ((const TRecEmcShower*) G__getstructoffset())->cellId());
12827 return(1 || funcname || hash || result7 || libp) ;
12828}
12829
12830static int G__RootEventData_rootcint_449_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12831{
12832 G__letint(result7, 105, (long) ((const TRecEmcShower*) G__getstructoffset())->module());
12833 return(1 || funcname || hash || result7 || libp) ;
12834}
12835
12836static int G__RootEventData_rootcint_449_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12837{
12838 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->x());
12839 return(1 || funcname || hash || result7 || libp) ;
12840}
12841
12842static int G__RootEventData_rootcint_449_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12843{
12844 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->y());
12845 return(1 || funcname || hash || result7 || libp) ;
12846}
12847
12848static int G__RootEventData_rootcint_449_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12849{
12850 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->z());
12851 return(1 || funcname || hash || result7 || libp) ;
12852}
12853
12854static int G__RootEventData_rootcint_449_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12855{
12856 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->theta());
12857 return(1 || funcname || hash || result7 || libp) ;
12858}
12859
12860static int G__RootEventData_rootcint_449_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12861{
12862 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->dtheta());
12863 return(1 || funcname || hash || result7 || libp) ;
12864}
12865
12866static int G__RootEventData_rootcint_449_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12867{
12868 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->phi());
12869 return(1 || funcname || hash || result7 || libp) ;
12870}
12871
12872static int G__RootEventData_rootcint_449_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12873{
12874 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->dphi());
12875 return(1 || funcname || hash || result7 || libp) ;
12876}
12877
12878static int G__RootEventData_rootcint_449_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12879{
12880 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->energy());
12881 return(1 || funcname || hash || result7 || libp) ;
12882}
12883
12884static int G__RootEventData_rootcint_449_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12885{
12886 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->dE());
12887 return(1 || funcname || hash || result7 || libp) ;
12888}
12889
12890static int G__RootEventData_rootcint_449_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12891{
12892 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->eSeed());
12893 return(1 || funcname || hash || result7 || libp) ;
12894}
12895
12896static int G__RootEventData_rootcint_449_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12897{
12898 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->e3x3());
12899 return(1 || funcname || hash || result7 || libp) ;
12900}
12901
12902static int G__RootEventData_rootcint_449_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12903{
12904 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->e5x5());
12905 return(1 || funcname || hash || result7 || libp) ;
12906}
12907
12908static int G__RootEventData_rootcint_449_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12909{
12910 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->eAll());
12911 return(1 || funcname || hash || result7 || libp) ;
12912}
12913
12914static int G__RootEventData_rootcint_449_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12915{
12916 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->eLepton());
12917 return(1 || funcname || hash || result7 || libp) ;
12918}
12919
12920static int G__RootEventData_rootcint_449_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12921{
12922 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->time());
12923 return(1 || funcname || hash || result7 || libp) ;
12924}
12925
12926static int G__RootEventData_rootcint_449_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12927{
12928 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->secondMoment());
12929 return(1 || funcname || hash || result7 || libp) ;
12930}
12931
12932static int G__RootEventData_rootcint_449_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12933{
12934 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->latMoment());
12935 return(1 || funcname || hash || result7 || libp) ;
12936}
12937
12938static int G__RootEventData_rootcint_449_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12939{
12940 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->a20Moment());
12941 return(1 || funcname || hash || result7 || libp) ;
12942}
12943
12944static int G__RootEventData_rootcint_449_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12945{
12946 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->a42Moment());
12947 return(1 || funcname || hash || result7 || libp) ;
12948}
12949
12950static int G__RootEventData_rootcint_449_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12951{
12952 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->err((Int_t) G__int(libp->para[0])));
12953 return(1 || funcname || hash || result7 || libp) ;
12954}
12955
12956static int G__RootEventData_rootcint_449_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12957{
12958 {
12959 const map<Int_t,Double_t>* pobj;
12960 const map<Int_t,Double_t> xobj = ((const TRecEmcShower*) G__getstructoffset())->cellIdMap();
12961 pobj = new map<Int_t,Double_t>(xobj);
12962 result7->obj.i = (long) ((void*) pobj);
12963 result7->ref = result7->obj.i;
12964 G__store_tempobject(*result7);
12965 }
12966 return(1 || funcname || hash || result7 || libp) ;
12967}
12968
12969static int G__RootEventData_rootcint_449_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12970{
12971 {
12972 const vector<Int_t>* pobj;
12973 const vector<Int_t> xobj = ((const TRecEmcShower*) G__getstructoffset())->cellId3x3();
12974 pobj = new vector<Int_t>(xobj);
12975 result7->obj.i = (long) ((void*) pobj);
12976 result7->ref = result7->obj.i;
12977 G__store_tempobject(*result7);
12978 }
12979 return(1 || funcname || hash || result7 || libp) ;
12980}
12981
12982static int G__RootEventData_rootcint_449_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12983{
12984 {
12985 const vector<Int_t>* pobj;
12986 const vector<Int_t> xobj = ((const TRecEmcShower*) G__getstructoffset())->cellId5x5();
12987 pobj = new vector<Int_t>(xobj);
12988 result7->obj.i = (long) ((void*) pobj);
12989 result7->ref = result7->obj.i;
12990 G__store_tempobject(*result7);
12991 }
12992 return(1 || funcname || hash || result7 || libp) ;
12993}
12994
12995static int G__RootEventData_rootcint_449_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12996{
12997 G__letint(result7, 105, (long) ((const TRecEmcShower*) G__getstructoffset())->clusterId());
12998 return(1 || funcname || hash || result7 || libp) ;
12999}
13000
13001static int G__RootEventData_rootcint_449_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13002{
13003 ((TRecEmcShower*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
13004 G__setnull(result7);
13005 return(1 || funcname || hash || result7 || libp) ;
13006}
13007
13008static int G__RootEventData_rootcint_449_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13009{
13010 ((TRecEmcShower*) G__getstructoffset())->setNumHits((const Int_t) G__int(libp->para[0]));
13011 G__setnull(result7);
13012 return(1 || funcname || hash || result7 || libp) ;
13013}
13014
13015static int G__RootEventData_rootcint_449_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13016{
13017 ((TRecEmcShower*) G__getstructoffset())->setStatus((const Int_t) G__int(libp->para[0]));
13018 G__setnull(result7);
13019 return(1 || funcname || hash || result7 || libp) ;
13020}
13021
13022static int G__RootEventData_rootcint_449_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13023{
13024 ((TRecEmcShower*) G__getstructoffset())->setCellId((const Int_t) G__int(libp->para[0]));
13025 G__setnull(result7);
13026 return(1 || funcname || hash || result7 || libp) ;
13027}
13028
13029static int G__RootEventData_rootcint_449_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13030{
13031 ((TRecEmcShower*) G__getstructoffset())->setModule((const Int_t) G__int(libp->para[0]));
13032 G__setnull(result7);
13033 return(1 || funcname || hash || result7 || libp) ;
13034}
13035
13036static int G__RootEventData_rootcint_449_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13037{
13038 ((TRecEmcShower*) G__getstructoffset())->setX((const Double_t) G__double(libp->para[0]));
13039 G__setnull(result7);
13040 return(1 || funcname || hash || result7 || libp) ;
13041}
13042
13043static int G__RootEventData_rootcint_449_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13044{
13045 ((TRecEmcShower*) G__getstructoffset())->setY((const Double_t) G__double(libp->para[0]));
13046 G__setnull(result7);
13047 return(1 || funcname || hash || result7 || libp) ;
13048}
13049
13050static int G__RootEventData_rootcint_449_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13051{
13052 ((TRecEmcShower*) G__getstructoffset())->setZ((const Double_t) G__double(libp->para[0]));
13053 G__setnull(result7);
13054 return(1 || funcname || hash || result7 || libp) ;
13055}
13056
13057static int G__RootEventData_rootcint_449_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13058{
13059 ((TRecEmcShower*) G__getstructoffset())->setEnergy((const Double_t) G__double(libp->para[0]));
13060 G__setnull(result7);
13061 return(1 || funcname || hash || result7 || libp) ;
13062}
13063
13064static int G__RootEventData_rootcint_449_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13065{
13066 ((TRecEmcShower*) G__getstructoffset())->setDE((const Double_t) G__double(libp->para[0]));
13067 G__setnull(result7);
13068 return(1 || funcname || hash || result7 || libp) ;
13069}
13070
13071static int G__RootEventData_rootcint_449_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13072{
13073 ((TRecEmcShower*) G__getstructoffset())->setTheta((const Double_t) G__double(libp->para[0]));
13074 G__setnull(result7);
13075 return(1 || funcname || hash || result7 || libp) ;
13076}
13077
13078static int G__RootEventData_rootcint_449_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13079{
13080 ((TRecEmcShower*) G__getstructoffset())->setDtheta((const Double_t) G__double(libp->para[0]));
13081 G__setnull(result7);
13082 return(1 || funcname || hash || result7 || libp) ;
13083}
13084
13085static int G__RootEventData_rootcint_449_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13086{
13087 ((TRecEmcShower*) G__getstructoffset())->setPhi((const Double_t) G__double(libp->para[0]));
13088 G__setnull(result7);
13089 return(1 || funcname || hash || result7 || libp) ;
13090}
13091
13092static int G__RootEventData_rootcint_449_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13093{
13094 ((TRecEmcShower*) G__getstructoffset())->setDphi((const Double_t) G__double(libp->para[0]));
13095 G__setnull(result7);
13096 return(1 || funcname || hash || result7 || libp) ;
13097}
13098
13099static int G__RootEventData_rootcint_449_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13100{
13101 ((TRecEmcShower*) G__getstructoffset())->setESeed((const Double_t) G__double(libp->para[0]));
13102 G__setnull(result7);
13103 return(1 || funcname || hash || result7 || libp) ;
13104}
13105
13106static int G__RootEventData_rootcint_449_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13107{
13108 ((TRecEmcShower*) G__getstructoffset())->setE3x3((const Double_t) G__double(libp->para[0]));
13109 G__setnull(result7);
13110 return(1 || funcname || hash || result7 || libp) ;
13111}
13112
13113static int G__RootEventData_rootcint_449_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13114{
13115 ((TRecEmcShower*) G__getstructoffset())->setE5x5((const Double_t) G__double(libp->para[0]));
13116 G__setnull(result7);
13117 return(1 || funcname || hash || result7 || libp) ;
13118}
13119
13120static int G__RootEventData_rootcint_449_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13121{
13122 ((TRecEmcShower*) G__getstructoffset())->setEAll((const Double_t) G__double(libp->para[0]));
13123 G__setnull(result7);
13124 return(1 || funcname || hash || result7 || libp) ;
13125}
13126
13127static int G__RootEventData_rootcint_449_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13128{
13129 ((TRecEmcShower*) G__getstructoffset())->setELepton((const Double_t) G__double(libp->para[0]));
13130 G__setnull(result7);
13131 return(1 || funcname || hash || result7 || libp) ;
13132}
13133
13134static int G__RootEventData_rootcint_449_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13135{
13136 ((TRecEmcShower*) G__getstructoffset())->setTime((const Double_t) G__double(libp->para[0]));
13137 G__setnull(result7);
13138 return(1 || funcname || hash || result7 || libp) ;
13139}
13140
13141static int G__RootEventData_rootcint_449_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13142{
13143 ((TRecEmcShower*) G__getstructoffset())->setSecondMoment((const Double_t) G__double(libp->para[0]));
13144 G__setnull(result7);
13145 return(1 || funcname || hash || result7 || libp) ;
13146}
13147
13148static int G__RootEventData_rootcint_449_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13149{
13150 ((TRecEmcShower*) G__getstructoffset())->setLatMoment((const Double_t) G__double(libp->para[0]));
13151 G__setnull(result7);
13152 return(1 || funcname || hash || result7 || libp) ;
13153}
13154
13155static int G__RootEventData_rootcint_449_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13156{
13157 ((TRecEmcShower*) G__getstructoffset())->setA20Moment((const Double_t) G__double(libp->para[0]));
13158 G__setnull(result7);
13159 return(1 || funcname || hash || result7 || libp) ;
13160}
13161
13162static int G__RootEventData_rootcint_449_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13163{
13164 ((TRecEmcShower*) G__getstructoffset())->setA42Moment((const Double_t) G__double(libp->para[0]));
13165 G__setnull(result7);
13166 return(1 || funcname || hash || result7 || libp) ;
13167}
13168
13169static int G__RootEventData_rootcint_449_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13170{
13171 ((TRecEmcShower*) G__getstructoffset())->setErr((Double_t*) G__int(libp->para[0]));
13172 G__setnull(result7);
13173 return(1 || funcname || hash || result7 || libp) ;
13174}
13175
13176static int G__RootEventData_rootcint_449_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13177{
13178 ((TRecEmcShower*) G__getstructoffset())->setCellIdMap(*(map<Int_t,Double_t>*) libp->para[0].ref);
13179 G__setnull(result7);
13180 return(1 || funcname || hash || result7 || libp) ;
13181}
13182
13183static int G__RootEventData_rootcint_449_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13184{
13185 ((TRecEmcShower*) G__getstructoffset())->setCellId3x3(*(vector<Int_t>*) libp->para[0].ref);
13186 G__setnull(result7);
13187 return(1 || funcname || hash || result7 || libp) ;
13188}
13189
13190static int G__RootEventData_rootcint_449_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13191{
13192 ((TRecEmcShower*) G__getstructoffset())->setCellId5x5(*(vector<Int_t>*) libp->para[0].ref);
13193 G__setnull(result7);
13194 return(1 || funcname || hash || result7 || libp) ;
13195}
13196
13197static int G__RootEventData_rootcint_449_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13198{
13199 ((TRecEmcShower*) G__getstructoffset())->setClusterId((const Int_t) G__int(libp->para[0]));
13200 G__setnull(result7);
13201 return(1 || funcname || hash || result7 || libp) ;
13202}
13203
13204static int G__RootEventData_rootcint_449_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13205{
13206 ((TRecEmcShower*) G__getstructoffset())->setTRecEmcShower((TRecEmcShower*) G__int(libp->para[0]));
13207 G__setnull(result7);
13208 return(1 || funcname || hash || result7 || libp) ;
13209}
13210
13211static int G__RootEventData_rootcint_449_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13212{
13213 G__letint(result7, 85, (long) TRecEmcShower::Class());
13214 return(1 || funcname || hash || result7 || libp) ;
13215}
13216
13217static int G__RootEventData_rootcint_449_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13218{
13219 G__letint(result7, 67, (long) TRecEmcShower::Class_Name());
13220 return(1 || funcname || hash || result7 || libp) ;
13221}
13222
13223static int G__RootEventData_rootcint_449_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13224{
13225 G__letint(result7, 115, (long) TRecEmcShower::Class_Version());
13226 return(1 || funcname || hash || result7 || libp) ;
13227}
13228
13229static int G__RootEventData_rootcint_449_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13230{
13231 TRecEmcShower::Dictionary();
13232 G__setnull(result7);
13233 return(1 || funcname || hash || result7 || libp) ;
13234}
13235
13236static int G__RootEventData_rootcint_449_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13237{
13238 ((TRecEmcShower*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
13239 G__setnull(result7);
13240 return(1 || funcname || hash || result7 || libp) ;
13241}
13242
13243static int G__RootEventData_rootcint_449_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13244{
13245 G__letint(result7, 67, (long) TRecEmcShower::DeclFileName());
13246 return(1 || funcname || hash || result7 || libp) ;
13247}
13248
13249static int G__RootEventData_rootcint_449_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13250{
13251 G__letint(result7, 105, (long) TRecEmcShower::ImplFileLine());
13252 return(1 || funcname || hash || result7 || libp) ;
13253}
13254
13255static int G__RootEventData_rootcint_449_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13256{
13257 G__letint(result7, 67, (long) TRecEmcShower::ImplFileName());
13258 return(1 || funcname || hash || result7 || libp) ;
13259}
13260
13261static int G__RootEventData_rootcint_449_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13262{
13263 G__letint(result7, 105, (long) TRecEmcShower::DeclFileLine());
13264 return(1 || funcname || hash || result7 || libp) ;
13265}
13266
13267// automatic copy constructor
13268static int G__RootEventData_rootcint_449_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13269
13270{
13271 TRecEmcShower* p;
13272 void* tmp = (void*) G__int(libp->para[0]);
13273 p = new TRecEmcShower(*(TRecEmcShower*) tmp);
13274 result7->obj.i = (long) p;
13275 result7->ref = (long) p;
13276 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower));
13277 return(1 || funcname || hash || result7 || libp) ;
13278}
13279
13280// automatic destructor
13281typedef TRecEmcShower G__TTRecEmcShower;
13282static int G__RootEventData_rootcint_449_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13283{
13284 char* gvp = (char*) G__getgvp();
13285 long soff = G__getstructoffset();
13286 int n = G__getaryconstruct();
13287 //
13288 //has_a_delete: 1
13289 //has_own_delete1arg: 0
13290 //has_own_delete2arg: 0
13291 //
13292 if (!soff) {
13293 return(1);
13294 }
13295 if (n) {
13296 if (gvp == (char*)G__PVOID) {
13297 delete[] (TRecEmcShower*) soff;
13298 } else {
13299 G__setgvp((long) G__PVOID);
13300 for (int i = n - 1; i >= 0; --i) {
13301 ((TRecEmcShower*) (soff+(sizeof(TRecEmcShower)*i)))->~G__TTRecEmcShower();
13302 }
13303 G__setgvp((long)gvp);
13304 }
13305 } else {
13306 if (gvp == (char*)G__PVOID) {
13307 delete (TRecEmcShower*) soff;
13308 } else {
13309 G__setgvp((long) G__PVOID);
13310 ((TRecEmcShower*) (soff))->~G__TTRecEmcShower();
13311 G__setgvp((long)gvp);
13312 }
13313 }
13314 G__setnull(result7);
13315 return(1 || funcname || hash || result7 || libp) ;
13316}
13317
13318// automatic assignment operator
13319static int G__RootEventData_rootcint_449_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13320{
13321 TRecEmcShower* dest = (TRecEmcShower*) G__getstructoffset();
13322 *dest = *(TRecEmcShower*) libp->para[0].ref;
13323 const TRecEmcShower& obj = *dest;
13324 result7->ref = (long) (&obj);
13325 result7->obj.i = (long) (&obj);
13326 return(1 || funcname || hash || result7 || libp) ;
13327}
13328
13329
13330/* TRecMucTrack */
13331static int G__RootEventData_rootcint_457_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13332{
13333 TRecMucTrack* p = NULL;
13334 char* gvp = (char*) G__getgvp();
13335 int n = G__getaryconstruct();
13336 if (n) {
13337 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13338 p = new TRecMucTrack[n];
13339 } else {
13340 p = new((void*) gvp) TRecMucTrack[n];
13341 }
13342 } else {
13343 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13344 p = new TRecMucTrack;
13345 } else {
13346 p = new((void*) gvp) TRecMucTrack;
13347 }
13348 }
13349 result7->obj.i = (long) p;
13350 result7->ref = (long) p;
13351 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack));
13352 return(1 || funcname || hash || result7 || libp) ;
13353}
13354
13355static int G__RootEventData_rootcint_457_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13356{
13357 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->trackId());
13358 return(1 || funcname || hash || result7 || libp) ;
13359}
13360
13361static int G__RootEventData_rootcint_457_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13362{
13363 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->id());
13364 return(1 || funcname || hash || result7 || libp) ;
13365}
13366
13367static int G__RootEventData_rootcint_457_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13368{
13369 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->status());
13370 return(1 || funcname || hash || result7 || libp) ;
13371}
13372
13373static int G__RootEventData_rootcint_457_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13374{
13375 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->type());
13376 return(1 || funcname || hash || result7 || libp) ;
13377}
13378
13379static int G__RootEventData_rootcint_457_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13380{
13381 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->startPart());
13382 return(1 || funcname || hash || result7 || libp) ;
13383}
13384
13385static int G__RootEventData_rootcint_457_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13386{
13387 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->endPart());
13388 return(1 || funcname || hash || result7 || libp) ;
13389}
13390
13391static int G__RootEventData_rootcint_457_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13392{
13393 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->brLastLayer());
13394 return(1 || funcname || hash || result7 || libp) ;
13395}
13396
13397static int G__RootEventData_rootcint_457_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13398{
13399 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->ecLastLayer());
13400 return(1 || funcname || hash || result7 || libp) ;
13401}
13402
13403static int G__RootEventData_rootcint_457_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13404{
13405 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->numHits());
13406 return(1 || funcname || hash || result7 || libp) ;
13407}
13408
13409static int G__RootEventData_rootcint_457_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13410{
13411 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->numLayers());
13412 return(1 || funcname || hash || result7 || libp) ;
13413}
13414
13415static int G__RootEventData_rootcint_457_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13416{
13417 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->maxHitsInLayer());
13418 return(1 || funcname || hash || result7 || libp) ;
13419}
13420
13421static int G__RootEventData_rootcint_457_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13422{
13423 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->depth());
13424 return(1 || funcname || hash || result7 || libp) ;
13425}
13426
13427static int G__RootEventData_rootcint_457_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13428{
13429 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->chi2());
13430 return(1 || funcname || hash || result7 || libp) ;
13431}
13432
13433static int G__RootEventData_rootcint_457_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13434{
13435 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->dof());
13436 return(1 || funcname || hash || result7 || libp) ;
13437}
13438
13439static int G__RootEventData_rootcint_457_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13440{
13441 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->rms());
13442 return(1 || funcname || hash || result7 || libp) ;
13443}
13444
13445static int G__RootEventData_rootcint_457_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13446{
13447 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->distance());
13448 return(1 || funcname || hash || result7 || libp) ;
13449}
13450
13451static int G__RootEventData_rootcint_457_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13452{
13453 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->deltaPhi());
13454 return(1 || funcname || hash || result7 || libp) ;
13455}
13456
13457static int G__RootEventData_rootcint_457_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13458{
13459 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->xPos());
13460 return(1 || funcname || hash || result7 || libp) ;
13461}
13462
13463static int G__RootEventData_rootcint_457_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13464{
13465 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->yPos());
13466 return(1 || funcname || hash || result7 || libp) ;
13467}
13468
13469static int G__RootEventData_rootcint_457_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13470{
13471 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->zPos());
13472 return(1 || funcname || hash || result7 || libp) ;
13473}
13474
13475static int G__RootEventData_rootcint_457_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13476{
13477 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->xPosSigma());
13478 return(1 || funcname || hash || result7 || libp) ;
13479}
13480
13481static int G__RootEventData_rootcint_457_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13482{
13483 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->yPosSigma());
13484 return(1 || funcname || hash || result7 || libp) ;
13485}
13486
13487static int G__RootEventData_rootcint_457_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13488{
13489 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->zPosSigma());
13490 return(1 || funcname || hash || result7 || libp) ;
13491}
13492
13493static int G__RootEventData_rootcint_457_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13494{
13495 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->px());
13496 return(1 || funcname || hash || result7 || libp) ;
13497}
13498
13499static int G__RootEventData_rootcint_457_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13500{
13501 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->py());
13502 return(1 || funcname || hash || result7 || libp) ;
13503}
13504
13505static int G__RootEventData_rootcint_457_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13506{
13507 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->pz());
13508 return(1 || funcname || hash || result7 || libp) ;
13509}
13510
13511static int G__RootEventData_rootcint_457_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13512{
13513 {
13514 const vector<Int_t>* pobj;
13515 const vector<Int_t> xobj = ((const TRecMucTrack*) G__getstructoffset())->vecHits();
13516 pobj = new vector<Int_t>(xobj);
13517 result7->obj.i = (long) ((void*) pobj);
13518 result7->ref = result7->obj.i;
13519 G__store_tempobject(*result7);
13520 }
13521 return(1 || funcname || hash || result7 || libp) ;
13522}
13523
13524static int G__RootEventData_rootcint_457_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13525{
13526 {
13527 const vector<Int_t>* pobj;
13528 const vector<Int_t> xobj = ((const TRecMucTrack*) G__getstructoffset())->expHits();
13529 pobj = new vector<Int_t>(xobj);
13530 result7->obj.i = (long) ((void*) pobj);
13531 result7->ref = result7->obj.i;
13532 G__store_tempobject(*result7);
13533 }
13534 return(1 || funcname || hash || result7 || libp) ;
13535}
13536
13537static int G__RootEventData_rootcint_457_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13538{
13539 {
13540 const vector<Float_t>* pobj;
13541 const vector<Float_t> xobj = ((const TRecMucTrack*) G__getstructoffset())->distHits();
13542 pobj = new vector<Float_t>(xobj);
13543 result7->obj.i = (long) ((void*) pobj);
13544 result7->ref = result7->obj.i;
13545 G__store_tempobject(*result7);
13546 }
13547 return(1 || funcname || hash || result7 || libp) ;
13548}
13549
13550static int G__RootEventData_rootcint_457_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13551{
13552 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->kalRechi2());
13553 return(1 || funcname || hash || result7 || libp) ;
13554}
13555
13556static int G__RootEventData_rootcint_457_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13557{
13558 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->kaldof());
13559 return(1 || funcname || hash || result7 || libp) ;
13560}
13561
13562static int G__RootEventData_rootcint_457_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13563{
13564 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->kaldepth());
13565 return(1 || funcname || hash || result7 || libp) ;
13566}
13567
13568static int G__RootEventData_rootcint_457_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13569{
13570 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->kalbrLastLayer());
13571 return(1 || funcname || hash || result7 || libp) ;
13572}
13573
13574static int G__RootEventData_rootcint_457_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13575{
13576 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->kalecLastLayer());
13577 return(1 || funcname || hash || result7 || libp) ;
13578}
13579
13580static int G__RootEventData_rootcint_457_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13581{
13582 ((TRecMucTrack*) G__getstructoffset())->setTrackId((Int_t) G__int(libp->para[0]));
13583 G__setnull(result7);
13584 return(1 || funcname || hash || result7 || libp) ;
13585}
13586
13587static int G__RootEventData_rootcint_457_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13588{
13589 ((TRecMucTrack*) G__getstructoffset())->setId((Int_t) G__int(libp->para[0]));
13590 G__setnull(result7);
13591 return(1 || funcname || hash || result7 || libp) ;
13592}
13593
13594static int G__RootEventData_rootcint_457_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13595{
13596 ((TRecMucTrack*) G__getstructoffset())->setStatus((Int_t) G__int(libp->para[0]));
13597 G__setnull(result7);
13598 return(1 || funcname || hash || result7 || libp) ;
13599}
13600
13601static int G__RootEventData_rootcint_457_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13602{
13603 ((TRecMucTrack*) G__getstructoffset())->setType((Int_t) G__int(libp->para[0]));
13604 G__setnull(result7);
13605 return(1 || funcname || hash || result7 || libp) ;
13606}
13607
13608static int G__RootEventData_rootcint_457_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13609{
13610 ((TRecMucTrack*) G__getstructoffset())->setStartPart((Int_t) G__int(libp->para[0]));
13611 G__setnull(result7);
13612 return(1 || funcname || hash || result7 || libp) ;
13613}
13614
13615static int G__RootEventData_rootcint_457_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13616{
13617 ((TRecMucTrack*) G__getstructoffset())->setEndPart((Int_t) G__int(libp->para[0]));
13618 G__setnull(result7);
13619 return(1 || funcname || hash || result7 || libp) ;
13620}
13621
13622static int G__RootEventData_rootcint_457_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13623{
13624 ((TRecMucTrack*) G__getstructoffset())->setBrLastLayer((Int_t) G__int(libp->para[0]));
13625 G__setnull(result7);
13626 return(1 || funcname || hash || result7 || libp) ;
13627}
13628
13629static int G__RootEventData_rootcint_457_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13630{
13631 ((TRecMucTrack*) G__getstructoffset())->setEcLastLayer((Int_t) G__int(libp->para[0]));
13632 G__setnull(result7);
13633 return(1 || funcname || hash || result7 || libp) ;
13634}
13635
13636static int G__RootEventData_rootcint_457_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13637{
13638 ((TRecMucTrack*) G__getstructoffset())->setNumHits((Int_t) G__int(libp->para[0]));
13639 G__setnull(result7);
13640 return(1 || funcname || hash || result7 || libp) ;
13641}
13642
13643static int G__RootEventData_rootcint_457_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13644{
13645 ((TRecMucTrack*) G__getstructoffset())->setNumLayers((Int_t) G__int(libp->para[0]));
13646 G__setnull(result7);
13647 return(1 || funcname || hash || result7 || libp) ;
13648}
13649
13650static int G__RootEventData_rootcint_457_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13651{
13652 ((TRecMucTrack*) G__getstructoffset())->setMaxHitsInLayer((Int_t) G__int(libp->para[0]));
13653 G__setnull(result7);
13654 return(1 || funcname || hash || result7 || libp) ;
13655}
13656
13657static int G__RootEventData_rootcint_457_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13658{
13659 ((TRecMucTrack*) G__getstructoffset())->setDepth((Double_t) G__double(libp->para[0]));
13660 G__setnull(result7);
13661 return(1 || funcname || hash || result7 || libp) ;
13662}
13663
13664static int G__RootEventData_rootcint_457_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13665{
13666 ((TRecMucTrack*) G__getstructoffset())->setChi2((Double_t) G__double(libp->para[0]));
13667 G__setnull(result7);
13668 return(1 || funcname || hash || result7 || libp) ;
13669}
13670
13671static int G__RootEventData_rootcint_457_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13672{
13673 ((TRecMucTrack*) G__getstructoffset())->setDof((Int_t) G__int(libp->para[0]));
13674 G__setnull(result7);
13675 return(1 || funcname || hash || result7 || libp) ;
13676}
13677
13678static int G__RootEventData_rootcint_457_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13679{
13680 ((TRecMucTrack*) G__getstructoffset())->setRms((Double_t) G__double(libp->para[0]));
13681 G__setnull(result7);
13682 return(1 || funcname || hash || result7 || libp) ;
13683}
13684
13685static int G__RootEventData_rootcint_457_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13686{
13687 ((TRecMucTrack*) G__getstructoffset())->setDistance((Double_t) G__double(libp->para[0]));
13688 G__setnull(result7);
13689 return(1 || funcname || hash || result7 || libp) ;
13690}
13691
13692static int G__RootEventData_rootcint_457_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13693{
13694 ((TRecMucTrack*) G__getstructoffset())->setDeltaPhi((Double_t) G__double(libp->para[0]));
13695 G__setnull(result7);
13696 return(1 || funcname || hash || result7 || libp) ;
13697}
13698
13699static int G__RootEventData_rootcint_457_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13700{
13701 ((TRecMucTrack*) G__getstructoffset())->setXPos((Double_t) G__double(libp->para[0]));
13702 G__setnull(result7);
13703 return(1 || funcname || hash || result7 || libp) ;
13704}
13705
13706static int G__RootEventData_rootcint_457_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13707{
13708 ((TRecMucTrack*) G__getstructoffset())->setYPos((Double_t) G__double(libp->para[0]));
13709 G__setnull(result7);
13710 return(1 || funcname || hash || result7 || libp) ;
13711}
13712
13713static int G__RootEventData_rootcint_457_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13714{
13715 ((TRecMucTrack*) G__getstructoffset())->setZPos((Double_t) G__double(libp->para[0]));
13716 G__setnull(result7);
13717 return(1 || funcname || hash || result7 || libp) ;
13718}
13719
13720static int G__RootEventData_rootcint_457_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13721{
13722 ((TRecMucTrack*) G__getstructoffset())->setXPosSigma((Double_t) G__double(libp->para[0]));
13723 G__setnull(result7);
13724 return(1 || funcname || hash || result7 || libp) ;
13725}
13726
13727static int G__RootEventData_rootcint_457_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13728{
13729 ((TRecMucTrack*) G__getstructoffset())->setYPosSigma((Double_t) G__double(libp->para[0]));
13730 G__setnull(result7);
13731 return(1 || funcname || hash || result7 || libp) ;
13732}
13733
13734static int G__RootEventData_rootcint_457_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13735{
13736 ((TRecMucTrack*) G__getstructoffset())->setZPosSigma((Double_t) G__double(libp->para[0]));
13737 G__setnull(result7);
13738 return(1 || funcname || hash || result7 || libp) ;
13739}
13740
13741static int G__RootEventData_rootcint_457_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13742{
13743 ((TRecMucTrack*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
13744 G__setnull(result7);
13745 return(1 || funcname || hash || result7 || libp) ;
13746}
13747
13748static int G__RootEventData_rootcint_457_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13749{
13750 ((TRecMucTrack*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
13751 G__setnull(result7);
13752 return(1 || funcname || hash || result7 || libp) ;
13753}
13754
13755static int G__RootEventData_rootcint_457_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13756{
13757 ((TRecMucTrack*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
13758 G__setnull(result7);
13759 return(1 || funcname || hash || result7 || libp) ;
13760}
13761
13762static int G__RootEventData_rootcint_457_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13763{
13764 ((TRecMucTrack*) G__getstructoffset())->setVecHits(*(vector<Int_t>*) libp->para[0].ref);
13765 G__setnull(result7);
13766 return(1 || funcname || hash || result7 || libp) ;
13767}
13768
13769static int G__RootEventData_rootcint_457_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13770{
13771 ((TRecMucTrack*) G__getstructoffset())->setExpHits(*(vector<Int_t>*) libp->para[0].ref);
13772 G__setnull(result7);
13773 return(1 || funcname || hash || result7 || libp) ;
13774}
13775
13776static int G__RootEventData_rootcint_457_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13777{
13778 ((TRecMucTrack*) G__getstructoffset())->setDistHits(*(vector<Float_t>*) libp->para[0].ref);
13779 G__setnull(result7);
13780 return(1 || funcname || hash || result7 || libp) ;
13781}
13782
13783static int G__RootEventData_rootcint_457_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13784{
13785 ((TRecMucTrack*) G__getstructoffset())->setkalRechi2((Double_t) G__double(libp->para[0]));
13786 G__setnull(result7);
13787 return(1 || funcname || hash || result7 || libp) ;
13788}
13789
13790static int G__RootEventData_rootcint_457_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13791{
13792 ((TRecMucTrack*) G__getstructoffset())->setkalDof((Int_t) G__int(libp->para[0]));
13793 G__setnull(result7);
13794 return(1 || funcname || hash || result7 || libp) ;
13795}
13796
13797static int G__RootEventData_rootcint_457_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13798{
13799 ((TRecMucTrack*) G__getstructoffset())->setkalDepth((Double_t) G__double(libp->para[0]));
13800 G__setnull(result7);
13801 return(1 || funcname || hash || result7 || libp) ;
13802}
13803
13804static int G__RootEventData_rootcint_457_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13805{
13806 ((TRecMucTrack*) G__getstructoffset())->setkalbrLastLayer((Int_t) G__int(libp->para[0]));
13807 G__setnull(result7);
13808 return(1 || funcname || hash || result7 || libp) ;
13809}
13810
13811static int G__RootEventData_rootcint_457_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13812{
13813 ((TRecMucTrack*) G__getstructoffset())->setkalecLastLayer((Int_t) G__int(libp->para[0]));
13814 G__setnull(result7);
13815 return(1 || funcname || hash || result7 || libp) ;
13816}
13817
13818static int G__RootEventData_rootcint_457_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13819{
13820 ((TRecMucTrack*) G__getstructoffset())->setTRecMucTrack((TRecMucTrack*) G__int(libp->para[0]));
13821 G__setnull(result7);
13822 return(1 || funcname || hash || result7 || libp) ;
13823}
13824
13825static int G__RootEventData_rootcint_457_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13826{
13827 G__letint(result7, 85, (long) TRecMucTrack::Class());
13828 return(1 || funcname || hash || result7 || libp) ;
13829}
13830
13831static int G__RootEventData_rootcint_457_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13832{
13833 G__letint(result7, 67, (long) TRecMucTrack::Class_Name());
13834 return(1 || funcname || hash || result7 || libp) ;
13835}
13836
13837static int G__RootEventData_rootcint_457_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13838{
13839 G__letint(result7, 115, (long) TRecMucTrack::Class_Version());
13840 return(1 || funcname || hash || result7 || libp) ;
13841}
13842
13843static int G__RootEventData_rootcint_457_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13844{
13845 TRecMucTrack::Dictionary();
13846 G__setnull(result7);
13847 return(1 || funcname || hash || result7 || libp) ;
13848}
13849
13850static int G__RootEventData_rootcint_457_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13851{
13852 ((TRecMucTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
13853 G__setnull(result7);
13854 return(1 || funcname || hash || result7 || libp) ;
13855}
13856
13857static int G__RootEventData_rootcint_457_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13858{
13859 G__letint(result7, 67, (long) TRecMucTrack::DeclFileName());
13860 return(1 || funcname || hash || result7 || libp) ;
13861}
13862
13863static int G__RootEventData_rootcint_457_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13864{
13865 G__letint(result7, 105, (long) TRecMucTrack::ImplFileLine());
13866 return(1 || funcname || hash || result7 || libp) ;
13867}
13868
13869static int G__RootEventData_rootcint_457_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13870{
13871 G__letint(result7, 67, (long) TRecMucTrack::ImplFileName());
13872 return(1 || funcname || hash || result7 || libp) ;
13873}
13874
13875static int G__RootEventData_rootcint_457_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13876{
13877 G__letint(result7, 105, (long) TRecMucTrack::DeclFileLine());
13878 return(1 || funcname || hash || result7 || libp) ;
13879}
13880
13881// automatic copy constructor
13882static int G__RootEventData_rootcint_457_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13883
13884{
13885 TRecMucTrack* p;
13886 void* tmp = (void*) G__int(libp->para[0]);
13887 p = new TRecMucTrack(*(TRecMucTrack*) tmp);
13888 result7->obj.i = (long) p;
13889 result7->ref = (long) p;
13890 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack));
13891 return(1 || funcname || hash || result7 || libp) ;
13892}
13893
13894// automatic destructor
13895typedef TRecMucTrack G__TTRecMucTrack;
13896static int G__RootEventData_rootcint_457_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13897{
13898 char* gvp = (char*) G__getgvp();
13899 long soff = G__getstructoffset();
13900 int n = G__getaryconstruct();
13901 //
13902 //has_a_delete: 1
13903 //has_own_delete1arg: 0
13904 //has_own_delete2arg: 0
13905 //
13906 if (!soff) {
13907 return(1);
13908 }
13909 if (n) {
13910 if (gvp == (char*)G__PVOID) {
13911 delete[] (TRecMucTrack*) soff;
13912 } else {
13913 G__setgvp((long) G__PVOID);
13914 for (int i = n - 1; i >= 0; --i) {
13915 ((TRecMucTrack*) (soff+(sizeof(TRecMucTrack)*i)))->~G__TTRecMucTrack();
13916 }
13917 G__setgvp((long)gvp);
13918 }
13919 } else {
13920 if (gvp == (char*)G__PVOID) {
13921 delete (TRecMucTrack*) soff;
13922 } else {
13923 G__setgvp((long) G__PVOID);
13924 ((TRecMucTrack*) (soff))->~G__TTRecMucTrack();
13925 G__setgvp((long)gvp);
13926 }
13927 }
13928 G__setnull(result7);
13929 return(1 || funcname || hash || result7 || libp) ;
13930}
13931
13932// automatic assignment operator
13933static int G__RootEventData_rootcint_457_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13934{
13935 TRecMucTrack* dest = (TRecMucTrack*) G__getstructoffset();
13936 *dest = *(TRecMucTrack*) libp->para[0].ref;
13937 const TRecMucTrack& obj = *dest;
13938 result7->ref = (long) (&obj);
13939 result7->obj.i = (long) (&obj);
13940 return(1 || funcname || hash || result7 || libp) ;
13941}
13942
13943
13944/* TRecMdcDedx */
13945static int G__RootEventData_rootcint_458_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13946{
13947 TRecMdcDedx* p = NULL;
13948 char* gvp = (char*) G__getgvp();
13949 int n = G__getaryconstruct();
13950 if (n) {
13951 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13952 p = new TRecMdcDedx[n];
13953 } else {
13954 p = new((void*) gvp) TRecMdcDedx[n];
13955 }
13956 } else {
13957 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13958 p = new TRecMdcDedx;
13959 } else {
13960 p = new((void*) gvp) TRecMdcDedx;
13961 }
13962 }
13963 result7->obj.i = (long) p;
13964 result7->ref = (long) p;
13965 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx));
13966 return(1 || funcname || hash || result7 || libp) ;
13967}
13968
13969static int G__RootEventData_rootcint_458_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13970{
13971 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->mdcTrackId());
13972 return(1 || funcname || hash || result7 || libp) ;
13973}
13974
13975static int G__RootEventData_rootcint_458_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13976{
13977 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->mdcKalTrackId());
13978 return(1 || funcname || hash || result7 || libp) ;
13979}
13980
13981static int G__RootEventData_rootcint_458_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13982{
13983 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->trackId());
13984 return(1 || funcname || hash || result7 || libp) ;
13985}
13986
13987static int G__RootEventData_rootcint_458_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13988{
13989 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->particleId());
13990 return(1 || funcname || hash || result7 || libp) ;
13991}
13992
13993static int G__RootEventData_rootcint_458_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13994{
13995 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->status());
13996 return(1 || funcname || hash || result7 || libp) ;
13997}
13998
13999static int G__RootEventData_rootcint_458_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14000{
14001 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->truncAlg());
14002 return(1 || funcname || hash || result7 || libp) ;
14003}
14004
14005static int G__RootEventData_rootcint_458_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14006{
14007 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chi((int) G__int(libp->para[0])));
14008 return(1 || funcname || hash || result7 || libp) ;
14009}
14010
14011static int G__RootEventData_rootcint_458_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14012{
14013 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiE());
14014 return(1 || funcname || hash || result7 || libp) ;
14015}
14016
14017static int G__RootEventData_rootcint_458_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14018{
14019 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiMu());
14020 return(1 || funcname || hash || result7 || libp) ;
14021}
14022
14023static int G__RootEventData_rootcint_458_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14024{
14025 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiPi());
14026 return(1 || funcname || hash || result7 || libp) ;
14027}
14028
14029static int G__RootEventData_rootcint_458_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14030{
14031 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiK());
14032 return(1 || funcname || hash || result7 || libp) ;
14033}
14034
14035static int G__RootEventData_rootcint_458_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14036{
14037 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiP());
14038 return(1 || funcname || hash || result7 || libp) ;
14039}
14040
14041static int G__RootEventData_rootcint_458_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14042{
14043 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->numGoodHits());
14044 return(1 || funcname || hash || result7 || libp) ;
14045}
14046
14047static int G__RootEventData_rootcint_458_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14048{
14049 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->numTotalHits());
14050 return(1 || funcname || hash || result7 || libp) ;
14051}
14052
14053static int G__RootEventData_rootcint_458_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14054{
14055 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->probPH());
14056 return(1 || funcname || hash || result7 || libp) ;
14057}
14058
14059static int G__RootEventData_rootcint_458_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14060{
14061 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->normPH());
14062 return(1 || funcname || hash || result7 || libp) ;
14063}
14064
14065static int G__RootEventData_rootcint_458_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14066{
14067 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->errorPH());
14068 return(1 || funcname || hash || result7 || libp) ;
14069}
14070
14071static int G__RootEventData_rootcint_458_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14072{
14073 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->twentyPH());
14074 return(1 || funcname || hash || result7 || libp) ;
14075}
14076
14077static int G__RootEventData_rootcint_458_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14078{
14079 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxExpect((int) G__int(libp->para[0])));
14080 return(1 || funcname || hash || result7 || libp) ;
14081}
14082
14083static int G__RootEventData_rootcint_458_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14084{
14085 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->sigmaDedx((int) G__int(libp->para[0])));
14086 return(1 || funcname || hash || result7 || libp) ;
14087}
14088
14089static int G__RootEventData_rootcint_458_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14090{
14091 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->pidProb((int) G__int(libp->para[0])));
14092 return(1 || funcname || hash || result7 || libp) ;
14093}
14094
14095static int G__RootEventData_rootcint_458_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14096{
14097 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxHit());
14098 return(1 || funcname || hash || result7 || libp) ;
14099}
14100
14101static int G__RootEventData_rootcint_458_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14102{
14103 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxEsat());
14104 return(1 || funcname || hash || result7 || libp) ;
14105}
14106
14107static int G__RootEventData_rootcint_458_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14108{
14109 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxNoRun());
14110 return(1 || funcname || hash || result7 || libp) ;
14111}
14112
14113static int G__RootEventData_rootcint_458_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14114{
14115 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxMoment());
14116 return(1 || funcname || hash || result7 || libp) ;
14117}
14118
14119static int G__RootEventData_rootcint_458_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14120{
14121 ((TRecMdcDedx*) G__getstructoffset())->setDedxHit((const Double_t) G__double(libp->para[0]));
14122 G__setnull(result7);
14123 return(1 || funcname || hash || result7 || libp) ;
14124}
14125
14126static int G__RootEventData_rootcint_458_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14127{
14128 ((TRecMdcDedx*) G__getstructoffset())->setDedxEsat((const Double_t) G__double(libp->para[0]));
14129 G__setnull(result7);
14130 return(1 || funcname || hash || result7 || libp) ;
14131}
14132
14133static int G__RootEventData_rootcint_458_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14134{
14135 ((TRecMdcDedx*) G__getstructoffset())->setDedxNoRun((const Double_t) G__double(libp->para[0]));
14136 G__setnull(result7);
14137 return(1 || funcname || hash || result7 || libp) ;
14138}
14139
14140static int G__RootEventData_rootcint_458_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14141{
14142 ((TRecMdcDedx*) G__getstructoffset())->setDedxMoment((const Double_t) G__double(libp->para[0]));
14143 G__setnull(result7);
14144 return(1 || funcname || hash || result7 || libp) ;
14145}
14146
14147static int G__RootEventData_rootcint_458_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14148{
14149 ((TRecMdcDedx*) G__getstructoffset())->setMdcTrackId((const int) G__int(libp->para[0]));
14150 G__setnull(result7);
14151 return(1 || funcname || hash || result7 || libp) ;
14152}
14153
14154static int G__RootEventData_rootcint_458_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14155{
14156 ((TRecMdcDedx*) G__getstructoffset())->setMdcKalTrackId((const int) G__int(libp->para[0]));
14157 G__setnull(result7);
14158 return(1 || funcname || hash || result7 || libp) ;
14159}
14160
14161static int G__RootEventData_rootcint_458_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14162{
14163 ((TRecMdcDedx*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
14164 G__setnull(result7);
14165 return(1 || funcname || hash || result7 || libp) ;
14166}
14167
14168static int G__RootEventData_rootcint_458_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14169{
14170 ((TRecMdcDedx*) G__getstructoffset())->setParticleId((const Int_t) G__int(libp->para[0]));
14171 G__setnull(result7);
14172 return(1 || funcname || hash || result7 || libp) ;
14173}
14174
14175static int G__RootEventData_rootcint_458_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14176{
14177 ((TRecMdcDedx*) G__getstructoffset())->setStatus((const Int_t) G__int(libp->para[0]));
14178 G__setnull(result7);
14179 return(1 || funcname || hash || result7 || libp) ;
14180}
14181
14182static int G__RootEventData_rootcint_458_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14183{
14184 ((TRecMdcDedx*) G__getstructoffset())->setTruncAlg((const Int_t) G__int(libp->para[0]));
14185 G__setnull(result7);
14186 return(1 || funcname || hash || result7 || libp) ;
14187}
14188
14189static int G__RootEventData_rootcint_458_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14190{
14191 ((TRecMdcDedx*) G__getstructoffset())->setChiE((const Double_t) G__double(libp->para[0]));
14192 G__setnull(result7);
14193 return(1 || funcname || hash || result7 || libp) ;
14194}
14195
14196static int G__RootEventData_rootcint_458_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14197{
14198 ((TRecMdcDedx*) G__getstructoffset())->setChiMu((const Double_t) G__double(libp->para[0]));
14199 G__setnull(result7);
14200 return(1 || funcname || hash || result7 || libp) ;
14201}
14202
14203static int G__RootEventData_rootcint_458_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14204{
14205 ((TRecMdcDedx*) G__getstructoffset())->setChiPi((const Double_t) G__double(libp->para[0]));
14206 G__setnull(result7);
14207 return(1 || funcname || hash || result7 || libp) ;
14208}
14209
14210static int G__RootEventData_rootcint_458_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14211{
14212 ((TRecMdcDedx*) G__getstructoffset())->setChiK((const Double_t) G__double(libp->para[0]));
14213 G__setnull(result7);
14214 return(1 || funcname || hash || result7 || libp) ;
14215}
14216
14217static int G__RootEventData_rootcint_458_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14218{
14219 ((TRecMdcDedx*) G__getstructoffset())->setChiP((const Double_t) G__double(libp->para[0]));
14220 G__setnull(result7);
14221 return(1 || funcname || hash || result7 || libp) ;
14222}
14223
14224static int G__RootEventData_rootcint_458_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14225{
14226 ((TRecMdcDedx*) G__getstructoffset())->setNumGoodHits((const Int_t) G__int(libp->para[0]));
14227 G__setnull(result7);
14228 return(1 || funcname || hash || result7 || libp) ;
14229}
14230
14231static int G__RootEventData_rootcint_458_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14232{
14233 ((TRecMdcDedx*) G__getstructoffset())->setNumTotalHits((const Int_t) G__int(libp->para[0]));
14234 G__setnull(result7);
14235 return(1 || funcname || hash || result7 || libp) ;
14236}
14237
14238static int G__RootEventData_rootcint_458_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14239{
14240 ((TRecMdcDedx*) G__getstructoffset())->setProbPH((const Double_t) G__double(libp->para[0]));
14241 G__setnull(result7);
14242 return(1 || funcname || hash || result7 || libp) ;
14243}
14244
14245static int G__RootEventData_rootcint_458_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14246{
14247 ((TRecMdcDedx*) G__getstructoffset())->setNormPH((const Double_t) G__double(libp->para[0]));
14248 G__setnull(result7);
14249 return(1 || funcname || hash || result7 || libp) ;
14250}
14251
14252static int G__RootEventData_rootcint_458_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14253{
14254 ((TRecMdcDedx*) G__getstructoffset())->setErrorPH((const Double_t) G__double(libp->para[0]));
14255 G__setnull(result7);
14256 return(1 || funcname || hash || result7 || libp) ;
14257}
14258
14259static int G__RootEventData_rootcint_458_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14260{
14261 ((TRecMdcDedx*) G__getstructoffset())->setTwentyPH((const Double_t) G__double(libp->para[0]));
14262 G__setnull(result7);
14263 return(1 || funcname || hash || result7 || libp) ;
14264}
14265
14266static int G__RootEventData_rootcint_458_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14267{
14268 ((TRecMdcDedx*) G__getstructoffset())->setChi((double*) G__int(libp->para[0]));
14269 G__setnull(result7);
14270 return(1 || funcname || hash || result7 || libp) ;
14271}
14272
14273static int G__RootEventData_rootcint_458_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14274{
14275 ((TRecMdcDedx*) G__getstructoffset())->setDedxExpect((double*) G__int(libp->para[0]));
14276 G__setnull(result7);
14277 return(1 || funcname || hash || result7 || libp) ;
14278}
14279
14280static int G__RootEventData_rootcint_458_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14281{
14282 ((TRecMdcDedx*) G__getstructoffset())->setSigmaDedx((double*) G__int(libp->para[0]));
14283 G__setnull(result7);
14284 return(1 || funcname || hash || result7 || libp) ;
14285}
14286
14287static int G__RootEventData_rootcint_458_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14288{
14289 ((TRecMdcDedx*) G__getstructoffset())->setPidProb((double*) G__int(libp->para[0]));
14290 G__setnull(result7);
14291 return(1 || funcname || hash || result7 || libp) ;
14292}
14293
14294static int G__RootEventData_rootcint_458_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14295{
14296 G__letint(result7, 85, (long) TRecMdcDedx::Class());
14297 return(1 || funcname || hash || result7 || libp) ;
14298}
14299
14300static int G__RootEventData_rootcint_458_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14301{
14302 G__letint(result7, 67, (long) TRecMdcDedx::Class_Name());
14303 return(1 || funcname || hash || result7 || libp) ;
14304}
14305
14306static int G__RootEventData_rootcint_458_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14307{
14308 G__letint(result7, 115, (long) TRecMdcDedx::Class_Version());
14309 return(1 || funcname || hash || result7 || libp) ;
14310}
14311
14312static int G__RootEventData_rootcint_458_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14313{
14314 TRecMdcDedx::Dictionary();
14315 G__setnull(result7);
14316 return(1 || funcname || hash || result7 || libp) ;
14317}
14318
14319static int G__RootEventData_rootcint_458_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14320{
14321 ((TRecMdcDedx*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
14322 G__setnull(result7);
14323 return(1 || funcname || hash || result7 || libp) ;
14324}
14325
14326static int G__RootEventData_rootcint_458_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14327{
14328 G__letint(result7, 67, (long) TRecMdcDedx::DeclFileName());
14329 return(1 || funcname || hash || result7 || libp) ;
14330}
14331
14332static int G__RootEventData_rootcint_458_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14333{
14334 G__letint(result7, 105, (long) TRecMdcDedx::ImplFileLine());
14335 return(1 || funcname || hash || result7 || libp) ;
14336}
14337
14338static int G__RootEventData_rootcint_458_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14339{
14340 G__letint(result7, 67, (long) TRecMdcDedx::ImplFileName());
14341 return(1 || funcname || hash || result7 || libp) ;
14342}
14343
14344static int G__RootEventData_rootcint_458_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14345{
14346 G__letint(result7, 105, (long) TRecMdcDedx::DeclFileLine());
14347 return(1 || funcname || hash || result7 || libp) ;
14348}
14349
14350// automatic copy constructor
14351static int G__RootEventData_rootcint_458_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14352
14353{
14354 TRecMdcDedx* p;
14355 void* tmp = (void*) G__int(libp->para[0]);
14356 p = new TRecMdcDedx(*(TRecMdcDedx*) tmp);
14357 result7->obj.i = (long) p;
14358 result7->ref = (long) p;
14359 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx));
14360 return(1 || funcname || hash || result7 || libp) ;
14361}
14362
14363// automatic destructor
14364typedef TRecMdcDedx G__TTRecMdcDedx;
14365static int G__RootEventData_rootcint_458_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14366{
14367 char* gvp = (char*) G__getgvp();
14368 long soff = G__getstructoffset();
14369 int n = G__getaryconstruct();
14370 //
14371 //has_a_delete: 1
14372 //has_own_delete1arg: 0
14373 //has_own_delete2arg: 0
14374 //
14375 if (!soff) {
14376 return(1);
14377 }
14378 if (n) {
14379 if (gvp == (char*)G__PVOID) {
14380 delete[] (TRecMdcDedx*) soff;
14381 } else {
14382 G__setgvp((long) G__PVOID);
14383 for (int i = n - 1; i >= 0; --i) {
14384 ((TRecMdcDedx*) (soff+(sizeof(TRecMdcDedx)*i)))->~G__TTRecMdcDedx();
14385 }
14386 G__setgvp((long)gvp);
14387 }
14388 } else {
14389 if (gvp == (char*)G__PVOID) {
14390 delete (TRecMdcDedx*) soff;
14391 } else {
14392 G__setgvp((long) G__PVOID);
14393 ((TRecMdcDedx*) (soff))->~G__TTRecMdcDedx();
14394 G__setgvp((long)gvp);
14395 }
14396 }
14397 G__setnull(result7);
14398 return(1 || funcname || hash || result7 || libp) ;
14399}
14400
14401// automatic assignment operator
14402static int G__RootEventData_rootcint_458_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14403{
14404 TRecMdcDedx* dest = (TRecMdcDedx*) G__getstructoffset();
14405 *dest = *(TRecMdcDedx*) libp->para[0].ref;
14406 const TRecMdcDedx& obj = *dest;
14407 result7->ref = (long) (&obj);
14408 result7->obj.i = (long) (&obj);
14409 return(1 || funcname || hash || result7 || libp) ;
14410}
14411
14412
14413/* TRecMdcDedxHit */
14414static int G__RootEventData_rootcint_459_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14415{
14416 TRecMdcDedxHit* p = NULL;
14417 char* gvp = (char*) G__getgvp();
14418 int n = G__getaryconstruct();
14419 if (n) {
14420 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14421 p = new TRecMdcDedxHit[n];
14422 } else {
14423 p = new((void*) gvp) TRecMdcDedxHit[n];
14424 }
14425 } else {
14426 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14427 p = new TRecMdcDedxHit;
14428 } else {
14429 p = new((void*) gvp) TRecMdcDedxHit;
14430 }
14431 }
14432 result7->obj.i = (long) p;
14433 result7->ref = (long) p;
14434 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit));
14435 return(1 || funcname || hash || result7 || libp) ;
14436}
14437
14438static int G__RootEventData_rootcint_459_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14439{
14440 G__letint(result7, 103, (long) ((TRecMdcDedxHit*) G__getstructoffset())->isGrouped());
14441 return(1 || funcname || hash || result7 || libp) ;
14442}
14443
14444static int G__RootEventData_rootcint_459_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14445{
14446 G__letint(result7, 105, (long) ((TRecMdcDedxHit*) G__getstructoffset())->mdcHitId());
14447 return(1 || funcname || hash || result7 || libp) ;
14448}
14449
14450static int G__RootEventData_rootcint_459_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14451{
14452 G__letint(result7, 105, (long) ((TRecMdcDedxHit*) G__getstructoffset())->mdcKalHelixSegId());
14453 return(1 || funcname || hash || result7 || libp) ;
14454}
14455
14456static int G__RootEventData_rootcint_459_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14457{
14458 G__letint(result7, 105, (long) ((const TRecMdcDedxHit*) G__getstructoffset())->trkId());
14459 return(1 || funcname || hash || result7 || libp) ;
14460}
14461
14462static int G__RootEventData_rootcint_459_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14463{
14464 G__letint(result7, 105, (long) ((const TRecMdcDedxHit*) G__getstructoffset())->flagLR());
14465 return(1 || funcname || hash || result7 || libp) ;
14466}
14467
14468static int G__RootEventData_rootcint_459_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14469{
14470 G__letint(result7, 104, (long) ((const TRecMdcDedxHit*) G__getstructoffset())->mdcId());
14471 return(1 || funcname || hash || result7 || libp) ;
14472}
14473
14474static int G__RootEventData_rootcint_459_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14475{
14476 G__letdouble(result7, 100, (double) ((const TRecMdcDedxHit*) G__getstructoffset())->pathLength());
14477 return(1 || funcname || hash || result7 || libp) ;
14478}
14479
14480static int G__RootEventData_rootcint_459_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14481{
14482 G__letdouble(result7, 100, (double) ((const TRecMdcDedxHit*) G__getstructoffset())->getDedx());
14483 return(1 || funcname || hash || result7 || libp) ;
14484}
14485
14486static int G__RootEventData_rootcint_459_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14487{
14488 ((TRecMdcDedxHit*) G__getstructoffset())->setMdcHitId((const int) G__int(libp->para[0]));
14489 G__setnull(result7);
14490 return(1 || funcname || hash || result7 || libp) ;
14491}
14492
14493static int G__RootEventData_rootcint_459_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14494{
14495 ((TRecMdcDedxHit*) G__getstructoffset())->setMdcKalHelixSegId((const int) G__int(libp->para[0]));
14496 G__setnull(result7);
14497 return(1 || funcname || hash || result7 || libp) ;
14498}
14499
14500static int G__RootEventData_rootcint_459_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14501{
14502 ((TRecMdcDedxHit*) G__getstructoffset())->setDedx((double) G__double(libp->para[0]));
14503 G__setnull(result7);
14504 return(1 || funcname || hash || result7 || libp) ;
14505}
14506
14507static int G__RootEventData_rootcint_459_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14508{
14509 ((TRecMdcDedxHit*) G__getstructoffset())->setIsGrouped((Bool_t) G__int(libp->para[0]));
14510 G__setnull(result7);
14511 return(1 || funcname || hash || result7 || libp) ;
14512}
14513
14514static int G__RootEventData_rootcint_459_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14515{
14516 ((TRecMdcDedxHit*) G__getstructoffset())->setTrkId((Int_t) G__int(libp->para[0]));
14517 G__setnull(result7);
14518 return(1 || funcname || hash || result7 || libp) ;
14519}
14520
14521static int G__RootEventData_rootcint_459_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14522{
14523 ((TRecMdcDedxHit*) G__getstructoffset())->setFlagLR((Int_t) G__int(libp->para[0]));
14524 G__setnull(result7);
14525 return(1 || funcname || hash || result7 || libp) ;
14526}
14527
14528static int G__RootEventData_rootcint_459_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14529{
14530 ((TRecMdcDedxHit*) G__getstructoffset())->setMdcId((UInt_t) G__int(libp->para[0]));
14531 G__setnull(result7);
14532 return(1 || funcname || hash || result7 || libp) ;
14533}
14534
14535static int G__RootEventData_rootcint_459_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14536{
14537 ((TRecMdcDedxHit*) G__getstructoffset())->setPathLength((double) G__double(libp->para[0]));
14538 G__setnull(result7);
14539 return(1 || funcname || hash || result7 || libp) ;
14540}
14541
14542static int G__RootEventData_rootcint_459_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14543{
14544 G__letint(result7, 85, (long) TRecMdcDedxHit::Class());
14545 return(1 || funcname || hash || result7 || libp) ;
14546}
14547
14548static int G__RootEventData_rootcint_459_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14549{
14550 G__letint(result7, 67, (long) TRecMdcDedxHit::Class_Name());
14551 return(1 || funcname || hash || result7 || libp) ;
14552}
14553
14554static int G__RootEventData_rootcint_459_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14555{
14556 G__letint(result7, 115, (long) TRecMdcDedxHit::Class_Version());
14557 return(1 || funcname || hash || result7 || libp) ;
14558}
14559
14560static int G__RootEventData_rootcint_459_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14561{
14562 TRecMdcDedxHit::Dictionary();
14563 G__setnull(result7);
14564 return(1 || funcname || hash || result7 || libp) ;
14565}
14566
14567static int G__RootEventData_rootcint_459_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14568{
14569 ((TRecMdcDedxHit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
14570 G__setnull(result7);
14571 return(1 || funcname || hash || result7 || libp) ;
14572}
14573
14574static int G__RootEventData_rootcint_459_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14575{
14576 G__letint(result7, 67, (long) TRecMdcDedxHit::DeclFileName());
14577 return(1 || funcname || hash || result7 || libp) ;
14578}
14579
14580static int G__RootEventData_rootcint_459_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14581{
14582 G__letint(result7, 105, (long) TRecMdcDedxHit::ImplFileLine());
14583 return(1 || funcname || hash || result7 || libp) ;
14584}
14585
14586static int G__RootEventData_rootcint_459_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14587{
14588 G__letint(result7, 67, (long) TRecMdcDedxHit::ImplFileName());
14589 return(1 || funcname || hash || result7 || libp) ;
14590}
14591
14592static int G__RootEventData_rootcint_459_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14593{
14594 G__letint(result7, 105, (long) TRecMdcDedxHit::DeclFileLine());
14595 return(1 || funcname || hash || result7 || libp) ;
14596}
14597
14598// automatic copy constructor
14599static int G__RootEventData_rootcint_459_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14600
14601{
14602 TRecMdcDedxHit* p;
14603 void* tmp = (void*) G__int(libp->para[0]);
14604 p = new TRecMdcDedxHit(*(TRecMdcDedxHit*) tmp);
14605 result7->obj.i = (long) p;
14606 result7->ref = (long) p;
14607 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit));
14608 return(1 || funcname || hash || result7 || libp) ;
14609}
14610
14611// automatic destructor
14612typedef TRecMdcDedxHit G__TTRecMdcDedxHit;
14613static int G__RootEventData_rootcint_459_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14614{
14615 char* gvp = (char*) G__getgvp();
14616 long soff = G__getstructoffset();
14617 int n = G__getaryconstruct();
14618 //
14619 //has_a_delete: 1
14620 //has_own_delete1arg: 0
14621 //has_own_delete2arg: 0
14622 //
14623 if (!soff) {
14624 return(1);
14625 }
14626 if (n) {
14627 if (gvp == (char*)G__PVOID) {
14628 delete[] (TRecMdcDedxHit*) soff;
14629 } else {
14630 G__setgvp((long) G__PVOID);
14631 for (int i = n - 1; i >= 0; --i) {
14632 ((TRecMdcDedxHit*) (soff+(sizeof(TRecMdcDedxHit)*i)))->~G__TTRecMdcDedxHit();
14633 }
14634 G__setgvp((long)gvp);
14635 }
14636 } else {
14637 if (gvp == (char*)G__PVOID) {
14638 delete (TRecMdcDedxHit*) soff;
14639 } else {
14640 G__setgvp((long) G__PVOID);
14641 ((TRecMdcDedxHit*) (soff))->~G__TTRecMdcDedxHit();
14642 G__setgvp((long)gvp);
14643 }
14644 }
14645 G__setnull(result7);
14646 return(1 || funcname || hash || result7 || libp) ;
14647}
14648
14649// automatic assignment operator
14650static int G__RootEventData_rootcint_459_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14651{
14652 TRecMdcDedxHit* dest = (TRecMdcDedxHit*) G__getstructoffset();
14653 *dest = *(TRecMdcDedxHit*) libp->para[0].ref;
14654 const TRecMdcDedxHit& obj = *dest;
14655 result7->ref = (long) (&obj);
14656 result7->obj.i = (long) (&obj);
14657 return(1 || funcname || hash || result7 || libp) ;
14658}
14659
14660
14661/* TRecExtTrack */
14662static int G__RootEventData_rootcint_460_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14663{
14664 TRecExtTrack* p = NULL;
14665 char* gvp = (char*) G__getgvp();
14666 int n = G__getaryconstruct();
14667 if (n) {
14668 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14669 p = new TRecExtTrack[n];
14670 } else {
14671 p = new((void*) gvp) TRecExtTrack[n];
14672 }
14673 } else {
14674 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14675 p = new TRecExtTrack;
14676 } else {
14677 p = new((void*) gvp) TRecExtTrack;
14678 }
14679 }
14680 result7->obj.i = (long) p;
14681 result7->ref = (long) p;
14682 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack));
14683 return(1 || funcname || hash || result7 || libp) ;
14684}
14685
14686static int G__RootEventData_rootcint_460_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14687{
14688 ((TRecExtTrack*) G__getstructoffset())->SetTrackId((const Int_t) G__int(libp->para[0]));
14689 G__setnull(result7);
14690 return(1 || funcname || hash || result7 || libp) ;
14691}
14692
14693static int G__RootEventData_rootcint_460_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14694{
14695 switch (libp->paran) {
14696 case 2:
14697 ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14698 G__setnull(result7);
14699 break;
14700 case 1:
14701 ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionX((const Double_t) G__double(libp->para[0]));
14702 G__setnull(result7);
14703 break;
14704 }
14705 return(1 || funcname || hash || result7 || libp) ;
14706}
14707
14708static int G__RootEventData_rootcint_460_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14709{
14710 switch (libp->paran) {
14711 case 2:
14712 ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14713 G__setnull(result7);
14714 break;
14715 case 1:
14716 ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionY((const Double_t) G__double(libp->para[0]));
14717 G__setnull(result7);
14718 break;
14719 }
14720 return(1 || funcname || hash || result7 || libp) ;
14721}
14722
14723static int G__RootEventData_rootcint_460_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14724{
14725 switch (libp->paran) {
14726 case 2:
14727 ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14728 G__setnull(result7);
14729 break;
14730 case 1:
14731 ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionZ((const Double_t) G__double(libp->para[0]));
14732 G__setnull(result7);
14733 break;
14734 }
14735 return(1 || funcname || hash || result7 || libp) ;
14736}
14737
14738static int G__RootEventData_rootcint_460_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14739{
14740 switch (libp->paran) {
14741 case 2:
14742 ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14743 G__setnull(result7);
14744 break;
14745 case 1:
14746 ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumX((const Double_t) G__double(libp->para[0]));
14747 G__setnull(result7);
14748 break;
14749 }
14750 return(1 || funcname || hash || result7 || libp) ;
14751}
14752
14753static int G__RootEventData_rootcint_460_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14754{
14755 switch (libp->paran) {
14756 case 2:
14757 ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14758 G__setnull(result7);
14759 break;
14760 case 1:
14761 ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumY((const Double_t) G__double(libp->para[0]));
14762 G__setnull(result7);
14763 break;
14764 }
14765 return(1 || funcname || hash || result7 || libp) ;
14766}
14767
14768static int G__RootEventData_rootcint_460_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14769{
14770 switch (libp->paran) {
14771 case 2:
14772 ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14773 G__setnull(result7);
14774 break;
14775 case 1:
14776 ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumZ((const Double_t) G__double(libp->para[0]));
14777 G__setnull(result7);
14778 break;
14779 }
14780 return(1 || funcname || hash || result7 || libp) ;
14781}
14782
14783static int G__RootEventData_rootcint_460_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14784{
14785 switch (libp->paran) {
14786 case 2:
14787 ((TRecExtTrack*) G__getstructoffset())->SetTof1VolumeName(*((const TString*) G__int(libp->para[0])), (const Int_t) G__int(libp->para[1]));
14788 G__setnull(result7);
14789 break;
14790 case 1:
14791 ((TRecExtTrack*) G__getstructoffset())->SetTof1VolumeName(*((const TString*) G__int(libp->para[0])));
14792 G__setnull(result7);
14793 break;
14794 }
14795 return(1 || funcname || hash || result7 || libp) ;
14796}
14797
14798static int G__RootEventData_rootcint_460_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14799{
14800 switch (libp->paran) {
14801 case 2:
14802 ((TRecExtTrack*) G__getstructoffset())->SetTof1VolumeNumber((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14803 G__setnull(result7);
14804 break;
14805 case 1:
14806 ((TRecExtTrack*) G__getstructoffset())->SetTof1VolumeNumber((const Int_t) G__int(libp->para[0]));
14807 G__setnull(result7);
14808 break;
14809 }
14810 return(1 || funcname || hash || result7 || libp) ;
14811}
14812
14813static int G__RootEventData_rootcint_460_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14814{
14815 switch (libp->paran) {
14816 case 2:
14817 ((TRecExtTrack*) G__getstructoffset())->SetTof1((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14818 G__setnull(result7);
14819 break;
14820 case 1:
14821 ((TRecExtTrack*) G__getstructoffset())->SetTof1((const Double_t) G__double(libp->para[0]));
14822 G__setnull(result7);
14823 break;
14824 }
14825 return(1 || funcname || hash || result7 || libp) ;
14826}
14827
14828static int G__RootEventData_rootcint_460_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14829{
14830 switch (libp->paran) {
14831 case 2:
14832 ((TRecExtTrack*) G__getstructoffset())->SetTof1Path((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14833 G__setnull(result7);
14834 break;
14835 case 1:
14836 ((TRecExtTrack*) G__getstructoffset())->SetTof1Path((const Double_t) G__double(libp->para[0]));
14837 G__setnull(result7);
14838 break;
14839 }
14840 return(1 || funcname || hash || result7 || libp) ;
14841}
14842
14843static int G__RootEventData_rootcint_460_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14844{
14845 switch (libp->paran) {
14846 case 2:
14847 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14848 G__setnull(result7);
14849 break;
14850 case 1:
14851 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
14852 G__setnull(result7);
14853 break;
14854 }
14855 return(1 || funcname || hash || result7 || libp) ;
14856}
14857
14858static int G__RootEventData_rootcint_460_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14859{
14860 switch (libp->paran) {
14861 case 2:
14862 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongT((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14863 G__setnull(result7);
14864 break;
14865 case 1:
14866 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongT((const Double_t) G__double(libp->para[0]));
14867 G__setnull(result7);
14868 break;
14869 }
14870 return(1 || funcname || hash || result7 || libp) ;
14871}
14872
14873static int G__RootEventData_rootcint_460_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14874{
14875 switch (libp->paran) {
14876 case 2:
14877 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14878 G__setnull(result7);
14879 break;
14880 case 1:
14881 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongX((const Double_t) G__double(libp->para[0]));
14882 G__setnull(result7);
14883 break;
14884 }
14885 return(1 || funcname || hash || result7 || libp) ;
14886}
14887
14888static int G__RootEventData_rootcint_460_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14889{
14890 switch (libp->paran) {
14891 case 2:
14892 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14893 G__setnull(result7);
14894 break;
14895 case 1:
14896 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongY((const Double_t) G__double(libp->para[0]));
14897 G__setnull(result7);
14898 break;
14899 }
14900 return(1 || funcname || hash || result7 || libp) ;
14901}
14902
14903static int G__RootEventData_rootcint_460_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14904{
14905 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
14906 switch (libp->paran) {
14907 case 2:
14908 ((TRecExtTrack*) G__getstructoffset())->SetTof1ErrorMatrix(G__Ap0->a, (const Int_t) G__int(libp->para[1]));
14909 G__setnull(result7);
14910 break;
14911 case 1:
14912 ((TRecExtTrack*) G__getstructoffset())->SetTof1ErrorMatrix(G__Ap0->a);
14913 G__setnull(result7);
14914 break;
14915 }
14916 return(1 || funcname || hash || result7 || libp) ;
14917}
14918
14919static int G__RootEventData_rootcint_460_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14920{
14921 switch (libp->paran) {
14922 case 2:
14923 ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14924 G__setnull(result7);
14925 break;
14926 case 1:
14927 ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionX((const Double_t) G__double(libp->para[0]));
14928 G__setnull(result7);
14929 break;
14930 }
14931 return(1 || funcname || hash || result7 || libp) ;
14932}
14933
14934static int G__RootEventData_rootcint_460_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14935{
14936 switch (libp->paran) {
14937 case 2:
14938 ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14939 G__setnull(result7);
14940 break;
14941 case 1:
14942 ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionY((const Double_t) G__double(libp->para[0]));
14943 G__setnull(result7);
14944 break;
14945 }
14946 return(1 || funcname || hash || result7 || libp) ;
14947}
14948
14949static int G__RootEventData_rootcint_460_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14950{
14951 switch (libp->paran) {
14952 case 2:
14953 ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14954 G__setnull(result7);
14955 break;
14956 case 1:
14957 ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionZ((const Double_t) G__double(libp->para[0]));
14958 G__setnull(result7);
14959 break;
14960 }
14961 return(1 || funcname || hash || result7 || libp) ;
14962}
14963
14964static int G__RootEventData_rootcint_460_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14965{
14966 switch (libp->paran) {
14967 case 2:
14968 ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14969 G__setnull(result7);
14970 break;
14971 case 1:
14972 ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumX((const Double_t) G__double(libp->para[0]));
14973 G__setnull(result7);
14974 break;
14975 }
14976 return(1 || funcname || hash || result7 || libp) ;
14977}
14978
14979static int G__RootEventData_rootcint_460_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14980{
14981 switch (libp->paran) {
14982 case 2:
14983 ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14984 G__setnull(result7);
14985 break;
14986 case 1:
14987 ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumY((const Double_t) G__double(libp->para[0]));
14988 G__setnull(result7);
14989 break;
14990 }
14991 return(1 || funcname || hash || result7 || libp) ;
14992}
14993
14994static int G__RootEventData_rootcint_460_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14995{
14996 switch (libp->paran) {
14997 case 2:
14998 ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14999 G__setnull(result7);
15000 break;
15001 case 1:
15002 ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumZ((const Double_t) G__double(libp->para[0]));
15003 G__setnull(result7);
15004 break;
15005 }
15006 return(1 || funcname || hash || result7 || libp) ;
15007}
15008
15009static int G__RootEventData_rootcint_460_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15010{
15011 switch (libp->paran) {
15012 case 2:
15013 ((TRecExtTrack*) G__getstructoffset())->SetTof2VolumeName(*((const TString*) G__int(libp->para[0])), (const Int_t) G__int(libp->para[1]));
15014 G__setnull(result7);
15015 break;
15016 case 1:
15017 ((TRecExtTrack*) G__getstructoffset())->SetTof2VolumeName(*((const TString*) G__int(libp->para[0])));
15018 G__setnull(result7);
15019 break;
15020 }
15021 return(1 || funcname || hash || result7 || libp) ;
15022}
15023
15024static int G__RootEventData_rootcint_460_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15025{
15026 switch (libp->paran) {
15027 case 2:
15028 ((TRecExtTrack*) G__getstructoffset())->SetTof2VolumeNumber((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15029 G__setnull(result7);
15030 break;
15031 case 1:
15032 ((TRecExtTrack*) G__getstructoffset())->SetTof2VolumeNumber((const Int_t) G__int(libp->para[0]));
15033 G__setnull(result7);
15034 break;
15035 }
15036 return(1 || funcname || hash || result7 || libp) ;
15037}
15038
15039static int G__RootEventData_rootcint_460_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15040{
15041 switch (libp->paran) {
15042 case 2:
15043 ((TRecExtTrack*) G__getstructoffset())->SetTof2((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15044 G__setnull(result7);
15045 break;
15046 case 1:
15047 ((TRecExtTrack*) G__getstructoffset())->SetTof2((const Double_t) G__double(libp->para[0]));
15048 G__setnull(result7);
15049 break;
15050 }
15051 return(1 || funcname || hash || result7 || libp) ;
15052}
15053
15054static int G__RootEventData_rootcint_460_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15055{
15056 switch (libp->paran) {
15057 case 2:
15058 ((TRecExtTrack*) G__getstructoffset())->SetTof2Path((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15059 G__setnull(result7);
15060 break;
15061 case 1:
15062 ((TRecExtTrack*) G__getstructoffset())->SetTof2Path((const Double_t) G__double(libp->para[0]));
15063 G__setnull(result7);
15064 break;
15065 }
15066 return(1 || funcname || hash || result7 || libp) ;
15067}
15068
15069static int G__RootEventData_rootcint_460_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15070{
15071 switch (libp->paran) {
15072 case 2:
15073 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15074 G__setnull(result7);
15075 break;
15076 case 1:
15077 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
15078 G__setnull(result7);
15079 break;
15080 }
15081 return(1 || funcname || hash || result7 || libp) ;
15082}
15083
15084static int G__RootEventData_rootcint_460_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15085{
15086 switch (libp->paran) {
15087 case 2:
15088 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongT((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15089 G__setnull(result7);
15090 break;
15091 case 1:
15092 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongT((const Double_t) G__double(libp->para[0]));
15093 G__setnull(result7);
15094 break;
15095 }
15096 return(1 || funcname || hash || result7 || libp) ;
15097}
15098
15099static int G__RootEventData_rootcint_460_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15100{
15101 switch (libp->paran) {
15102 case 2:
15103 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15104 G__setnull(result7);
15105 break;
15106 case 1:
15107 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongX((const Double_t) G__double(libp->para[0]));
15108 G__setnull(result7);
15109 break;
15110 }
15111 return(1 || funcname || hash || result7 || libp) ;
15112}
15113
15114static int G__RootEventData_rootcint_460_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15115{
15116 switch (libp->paran) {
15117 case 2:
15118 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15119 G__setnull(result7);
15120 break;
15121 case 1:
15122 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongY((const Double_t) G__double(libp->para[0]));
15123 G__setnull(result7);
15124 break;
15125 }
15126 return(1 || funcname || hash || result7 || libp) ;
15127}
15128
15129static int G__RootEventData_rootcint_460_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15130{
15131 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
15132 switch (libp->paran) {
15133 case 2:
15134 ((TRecExtTrack*) G__getstructoffset())->SetTof2ErrorMatrix(G__Ap0->a, (const Int_t) G__int(libp->para[1]));
15135 G__setnull(result7);
15136 break;
15137 case 1:
15138 ((TRecExtTrack*) G__getstructoffset())->SetTof2ErrorMatrix(G__Ap0->a);
15139 G__setnull(result7);
15140 break;
15141 }
15142 return(1 || funcname || hash || result7 || libp) ;
15143}
15144
15145static int G__RootEventData_rootcint_460_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15146{
15147 switch (libp->paran) {
15148 case 2:
15149 ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15150 G__setnull(result7);
15151 break;
15152 case 1:
15153 ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionX((const Double_t) G__double(libp->para[0]));
15154 G__setnull(result7);
15155 break;
15156 }
15157 return(1 || funcname || hash || result7 || libp) ;
15158}
15159
15160static int G__RootEventData_rootcint_460_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15161{
15162 switch (libp->paran) {
15163 case 2:
15164 ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15165 G__setnull(result7);
15166 break;
15167 case 1:
15168 ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionY((const Double_t) G__double(libp->para[0]));
15169 G__setnull(result7);
15170 break;
15171 }
15172 return(1 || funcname || hash || result7 || libp) ;
15173}
15174
15175static int G__RootEventData_rootcint_460_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15176{
15177 switch (libp->paran) {
15178 case 2:
15179 ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15180 G__setnull(result7);
15181 break;
15182 case 1:
15183 ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionZ((const Double_t) G__double(libp->para[0]));
15184 G__setnull(result7);
15185 break;
15186 }
15187 return(1 || funcname || hash || result7 || libp) ;
15188}
15189
15190static int G__RootEventData_rootcint_460_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15191{
15192 switch (libp->paran) {
15193 case 2:
15194 ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15195 G__setnull(result7);
15196 break;
15197 case 1:
15198 ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumX((const Double_t) G__double(libp->para[0]));
15199 G__setnull(result7);
15200 break;
15201 }
15202 return(1 || funcname || hash || result7 || libp) ;
15203}
15204
15205static int G__RootEventData_rootcint_460_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15206{
15207 switch (libp->paran) {
15208 case 2:
15209 ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15210 G__setnull(result7);
15211 break;
15212 case 1:
15213 ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumY((const Double_t) G__double(libp->para[0]));
15214 G__setnull(result7);
15215 break;
15216 }
15217 return(1 || funcname || hash || result7 || libp) ;
15218}
15219
15220static int G__RootEventData_rootcint_460_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15221{
15222 switch (libp->paran) {
15223 case 2:
15224 ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15225 G__setnull(result7);
15226 break;
15227 case 1:
15228 ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumZ((const Double_t) G__double(libp->para[0]));
15229 G__setnull(result7);
15230 break;
15231 }
15232 return(1 || funcname || hash || result7 || libp) ;
15233}
15234
15235static int G__RootEventData_rootcint_460_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15236{
15237 switch (libp->paran) {
15238 case 2:
15239 ((TRecExtTrack*) G__getstructoffset())->SetEmcVolumeName(*((const TString*) G__int(libp->para[0])), (const Int_t) G__int(libp->para[1]));
15240 G__setnull(result7);
15241 break;
15242 case 1:
15243 ((TRecExtTrack*) G__getstructoffset())->SetEmcVolumeName(*((const TString*) G__int(libp->para[0])));
15244 G__setnull(result7);
15245 break;
15246 }
15247 return(1 || funcname || hash || result7 || libp) ;
15248}
15249
15250static int G__RootEventData_rootcint_460_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15251{
15252 switch (libp->paran) {
15253 case 2:
15254 ((TRecExtTrack*) G__getstructoffset())->SetEmcVolumeNumber((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15255 G__setnull(result7);
15256 break;
15257 case 1:
15258 ((TRecExtTrack*) G__getstructoffset())->SetEmcVolumeNumber((const Int_t) G__int(libp->para[0]));
15259 G__setnull(result7);
15260 break;
15261 }
15262 return(1 || funcname || hash || result7 || libp) ;
15263}
15264
15265static int G__RootEventData_rootcint_460_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15266{
15267 switch (libp->paran) {
15268 case 2:
15269 ((TRecExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongTheta((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15270 G__setnull(result7);
15271 break;
15272 case 1:
15273 ((TRecExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongTheta((const Double_t) G__double(libp->para[0]));
15274 G__setnull(result7);
15275 break;
15276 }
15277 return(1 || funcname || hash || result7 || libp) ;
15278}
15279
15280static int G__RootEventData_rootcint_460_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15281{
15282 switch (libp->paran) {
15283 case 2:
15284 ((TRecExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongPhi((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15285 G__setnull(result7);
15286 break;
15287 case 1:
15288 ((TRecExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongPhi((const Double_t) G__double(libp->para[0]));
15289 G__setnull(result7);
15290 break;
15291 }
15292 return(1 || funcname || hash || result7 || libp) ;
15293}
15294
15295static int G__RootEventData_rootcint_460_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15296{
15297 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
15298 switch (libp->paran) {
15299 case 2:
15300 ((TRecExtTrack*) G__getstructoffset())->SetEmcErrorMatrix(G__Ap0->a, (const Int_t) G__int(libp->para[1]));
15301 G__setnull(result7);
15302 break;
15303 case 1:
15304 ((TRecExtTrack*) G__getstructoffset())->SetEmcErrorMatrix(G__Ap0->a);
15305 G__setnull(result7);
15306 break;
15307 }
15308 return(1 || funcname || hash || result7 || libp) ;
15309}
15310
15311static int G__RootEventData_rootcint_460_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15312{
15313 switch (libp->paran) {
15314 case 2:
15315 ((TRecExtTrack*) G__getstructoffset())->SetEmcPath((Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15316 G__setnull(result7);
15317 break;
15318 case 1:
15319 ((TRecExtTrack*) G__getstructoffset())->SetEmcPath((Double_t) G__double(libp->para[0]));
15320 G__setnull(result7);
15321 break;
15322 }
15323 return(1 || funcname || hash || result7 || libp) ;
15324}
15325
15326static int G__RootEventData_rootcint_460_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15327{
15328 switch (libp->paran) {
15329 case 2:
15330 ((TRecExtTrack*) G__getstructoffset())->SetMucPositionX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15331 G__setnull(result7);
15332 break;
15333 case 1:
15334 ((TRecExtTrack*) G__getstructoffset())->SetMucPositionX((const Double_t) G__double(libp->para[0]));
15335 G__setnull(result7);
15336 break;
15337 }
15338 return(1 || funcname || hash || result7 || libp) ;
15339}
15340
15341static int G__RootEventData_rootcint_460_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15342{
15343 switch (libp->paran) {
15344 case 2:
15345 ((TRecExtTrack*) G__getstructoffset())->SetMucPositionY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15346 G__setnull(result7);
15347 break;
15348 case 1:
15349 ((TRecExtTrack*) G__getstructoffset())->SetMucPositionY((const Double_t) G__double(libp->para[0]));
15350 G__setnull(result7);
15351 break;
15352 }
15353 return(1 || funcname || hash || result7 || libp) ;
15354}
15355
15356static int G__RootEventData_rootcint_460_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15357{
15358 switch (libp->paran) {
15359 case 2:
15360 ((TRecExtTrack*) G__getstructoffset())->SetMucPositionZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15361 G__setnull(result7);
15362 break;
15363 case 1:
15364 ((TRecExtTrack*) G__getstructoffset())->SetMucPositionZ((const Double_t) G__double(libp->para[0]));
15365 G__setnull(result7);
15366 break;
15367 }
15368 return(1 || funcname || hash || result7 || libp) ;
15369}
15370
15371static int G__RootEventData_rootcint_460_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15372{
15373 switch (libp->paran) {
15374 case 2:
15375 ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15376 G__setnull(result7);
15377 break;
15378 case 1:
15379 ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumX((const Double_t) G__double(libp->para[0]));
15380 G__setnull(result7);
15381 break;
15382 }
15383 return(1 || funcname || hash || result7 || libp) ;
15384}
15385
15386static int G__RootEventData_rootcint_460_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15387{
15388 switch (libp->paran) {
15389 case 2:
15390 ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15391 G__setnull(result7);
15392 break;
15393 case 1:
15394 ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumY((const Double_t) G__double(libp->para[0]));
15395 G__setnull(result7);
15396 break;
15397 }
15398 return(1 || funcname || hash || result7 || libp) ;
15399}
15400
15401static int G__RootEventData_rootcint_460_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15402{
15403 switch (libp->paran) {
15404 case 2:
15405 ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15406 G__setnull(result7);
15407 break;
15408 case 1:
15409 ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumZ((const Double_t) G__double(libp->para[0]));
15410 G__setnull(result7);
15411 break;
15412 }
15413 return(1 || funcname || hash || result7 || libp) ;
15414}
15415
15416static int G__RootEventData_rootcint_460_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15417{
15418 switch (libp->paran) {
15419 case 2:
15420 ((TRecExtTrack*) G__getstructoffset())->SetMucVolumeName(*((const TString*) G__int(libp->para[0])), (const Int_t) G__int(libp->para[1]));
15421 G__setnull(result7);
15422 break;
15423 case 1:
15424 ((TRecExtTrack*) G__getstructoffset())->SetMucVolumeName(*((const TString*) G__int(libp->para[0])));
15425 G__setnull(result7);
15426 break;
15427 }
15428 return(1 || funcname || hash || result7 || libp) ;
15429}
15430
15431static int G__RootEventData_rootcint_460_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15432{
15433 switch (libp->paran) {
15434 case 2:
15435 ((TRecExtTrack*) G__getstructoffset())->SetMucVolumeNumber((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15436 G__setnull(result7);
15437 break;
15438 case 1:
15439 ((TRecExtTrack*) G__getstructoffset())->SetMucVolumeNumber((const Int_t) G__int(libp->para[0]));
15440 G__setnull(result7);
15441 break;
15442 }
15443 return(1 || funcname || hash || result7 || libp) ;
15444}
15445
15446static int G__RootEventData_rootcint_460_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15447{
15448 switch (libp->paran) {
15449 case 2:
15450 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15451 G__setnull(result7);
15452 break;
15453 case 1:
15454 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
15455 G__setnull(result7);
15456 break;
15457 }
15458 return(1 || funcname || hash || result7 || libp) ;
15459}
15460
15461static int G__RootEventData_rootcint_460_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15462{
15463 switch (libp->paran) {
15464 case 2:
15465 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongT((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15466 G__setnull(result7);
15467 break;
15468 case 1:
15469 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongT((const Double_t) G__double(libp->para[0]));
15470 G__setnull(result7);
15471 break;
15472 }
15473 return(1 || funcname || hash || result7 || libp) ;
15474}
15475
15476static int G__RootEventData_rootcint_460_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15477{
15478 switch (libp->paran) {
15479 case 2:
15480 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15481 G__setnull(result7);
15482 break;
15483 case 1:
15484 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongX((const Double_t) G__double(libp->para[0]));
15485 G__setnull(result7);
15486 break;
15487 }
15488 return(1 || funcname || hash || result7 || libp) ;
15489}
15490
15491static int G__RootEventData_rootcint_460_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15492{
15493 switch (libp->paran) {
15494 case 2:
15495 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15496 G__setnull(result7);
15497 break;
15498 case 1:
15499 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongY((const Double_t) G__double(libp->para[0]));
15500 G__setnull(result7);
15501 break;
15502 }
15503 return(1 || funcname || hash || result7 || libp) ;
15504}
15505
15506static int G__RootEventData_rootcint_460_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15507{
15508 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
15509 switch (libp->paran) {
15510 case 2:
15511 ((TRecExtTrack*) G__getstructoffset())->SetMucErrorMatrix(G__Ap0->a, (const Int_t) G__int(libp->para[1]));
15512 G__setnull(result7);
15513 break;
15514 case 1:
15515 ((TRecExtTrack*) G__getstructoffset())->SetMucErrorMatrix(G__Ap0->a);
15516 G__setnull(result7);
15517 break;
15518 }
15519 return(1 || funcname || hash || result7 || libp) ;
15520}
15521
15522static int G__RootEventData_rootcint_460_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15523{
15524 switch (libp->paran) {
15525 case 2:
15526 ((TRecExtTrack*) G__getstructoffset())->SetSize((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15527 G__setnull(result7);
15528 break;
15529 case 1:
15530 ((TRecExtTrack*) G__getstructoffset())->SetSize((Int_t) G__int(libp->para[0]));
15531 G__setnull(result7);
15532 break;
15533 }
15534 return(1 || funcname || hash || result7 || libp) ;
15535}
15536
15537static int G__RootEventData_rootcint_460_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15538{
15539 struct G__aRyp12 { Double_t a[1][6]; }* G__Ap12 = (struct G__aRyp12*) G__int(libp->para[12]);
15540 switch (libp->paran) {
15541 case 14:
15542 ((TRecExtTrack*) G__getstructoffset())->SetExtMucHit(
15543(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
15544, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
15545, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
15546, *((TString*) G__int(libp->para[6])), (Int_t) G__int(libp->para[7])
15547, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
15548, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
15549, G__Ap12->a, (const Int_t) G__int(libp->para[13]));
15550 G__setnull(result7);
15551 break;
15552 case 13:
15553 ((TRecExtTrack*) G__getstructoffset())->SetExtMucHit(
15554(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
15555, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
15556, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
15557, *((TString*) G__int(libp->para[6])), (Int_t) G__int(libp->para[7])
15558, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
15559, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
15560, G__Ap12->a);
15561 G__setnull(result7);
15562 break;
15563 }
15564 return(1 || funcname || hash || result7 || libp) ;
15565}
15566
15567static int G__RootEventData_rootcint_460_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15568{
15569 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTrackId());
15570 return(1 || funcname || hash || result7 || libp) ;
15571}
15572
15573static int G__RootEventData_rootcint_460_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15574{
15575 switch (libp->paran) {
15576 case 1:
15577 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionX((const Int_t) G__int(libp->para[0])));
15578 break;
15579 case 0:
15580 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionX());
15581 break;
15582 }
15583 return(1 || funcname || hash || result7 || libp) ;
15584}
15585
15586static int G__RootEventData_rootcint_460_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15587{
15588 switch (libp->paran) {
15589 case 1:
15590 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionY((const Int_t) G__int(libp->para[0])));
15591 break;
15592 case 0:
15593 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionY());
15594 break;
15595 }
15596 return(1 || funcname || hash || result7 || libp) ;
15597}
15598
15599static int G__RootEventData_rootcint_460_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15600{
15601 switch (libp->paran) {
15602 case 1:
15603 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionZ((const Int_t) G__int(libp->para[0])));
15604 break;
15605 case 0:
15606 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionZ());
15607 break;
15608 }
15609 return(1 || funcname || hash || result7 || libp) ;
15610}
15611
15612static int G__RootEventData_rootcint_460_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15613{
15614 switch (libp->paran) {
15615 case 1:
15616 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumX((const Int_t) G__int(libp->para[0])));
15617 break;
15618 case 0:
15619 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumX());
15620 break;
15621 }
15622 return(1 || funcname || hash || result7 || libp) ;
15623}
15624
15625static int G__RootEventData_rootcint_460_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15626{
15627 switch (libp->paran) {
15628 case 1:
15629 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumY((const Int_t) G__int(libp->para[0])));
15630 break;
15631 case 0:
15632 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumY());
15633 break;
15634 }
15635 return(1 || funcname || hash || result7 || libp) ;
15636}
15637
15638static int G__RootEventData_rootcint_460_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15639{
15640 switch (libp->paran) {
15641 case 1:
15642 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumZ((const Int_t) G__int(libp->para[0])));
15643 break;
15644 case 0:
15645 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumZ());
15646 break;
15647 }
15648 return(1 || funcname || hash || result7 || libp) ;
15649}
15650
15651static int G__RootEventData_rootcint_460_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15652{
15653 switch (libp->paran) {
15654 case 1:
15655 {
15656 const TString* pobj;
15657 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetTof1VolumeName((const Int_t) G__int(libp->para[0]));
15658 pobj = new TString(xobj);
15659 result7->obj.i = (long) ((void*) pobj);
15660 result7->ref = result7->obj.i;
15661 G__store_tempobject(*result7);
15662 }
15663 break;
15664 case 0:
15665 {
15666 const TString* pobj;
15667 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetTof1VolumeName();
15668 pobj = new TString(xobj);
15669 result7->obj.i = (long) ((void*) pobj);
15670 result7->ref = result7->obj.i;
15671 G__store_tempobject(*result7);
15672 }
15673 break;
15674 }
15675 return(1 || funcname || hash || result7 || libp) ;
15676}
15677
15678static int G__RootEventData_rootcint_460_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15679{
15680 switch (libp->paran) {
15681 case 1:
15682 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTof1VolumeNumber((const Int_t) G__int(libp->para[0])));
15683 break;
15684 case 0:
15685 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTof1VolumeNumber());
15686 break;
15687 }
15688 return(1 || funcname || hash || result7 || libp) ;
15689}
15690
15691static int G__RootEventData_rootcint_460_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15692{
15693 switch (libp->paran) {
15694 case 1:
15695 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1((const Int_t) G__int(libp->para[0])));
15696 break;
15697 case 0:
15698 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1());
15699 break;
15700 }
15701 return(1 || funcname || hash || result7 || libp) ;
15702}
15703
15704static int G__RootEventData_rootcint_460_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15705{
15706 switch (libp->paran) {
15707 case 1:
15708 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1Path((const Int_t) G__int(libp->para[0])));
15709 break;
15710 case 0:
15711 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1Path());
15712 break;
15713 }
15714 return(1 || funcname || hash || result7 || libp) ;
15715}
15716
15717static int G__RootEventData_rootcint_460_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15718{
15719 switch (libp->paran) {
15720 case 1:
15721 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongZ((const Int_t) G__int(libp->para[0])));
15722 break;
15723 case 0:
15724 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongZ());
15725 break;
15726 }
15727 return(1 || funcname || hash || result7 || libp) ;
15728}
15729
15730static int G__RootEventData_rootcint_460_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15731{
15732 switch (libp->paran) {
15733 case 1:
15734 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongT((const Int_t) G__int(libp->para[0])));
15735 break;
15736 case 0:
15737 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongT());
15738 break;
15739 }
15740 return(1 || funcname || hash || result7 || libp) ;
15741}
15742
15743static int G__RootEventData_rootcint_460_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15744{
15745 switch (libp->paran) {
15746 case 1:
15747 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongX((const Int_t) G__int(libp->para[0])));
15748 break;
15749 case 0:
15750 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongX());
15751 break;
15752 }
15753 return(1 || funcname || hash || result7 || libp) ;
15754}
15755
15756static int G__RootEventData_rootcint_460_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15757{
15758 switch (libp->paran) {
15759 case 1:
15760 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongY((const Int_t) G__int(libp->para[0])));
15761 break;
15762 case 0:
15763 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongY());
15764 break;
15765 }
15766 return(1 || funcname || hash || result7 || libp) ;
15767}
15768
15769static int G__RootEventData_rootcint_460_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15770{
15771 switch (libp->paran) {
15772 case 3:
15773 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
15774, (const Int_t) G__int(libp->para[2])));
15775 break;
15776 case 2:
15777 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
15778 break;
15779 }
15780 return(1 || funcname || hash || result7 || libp) ;
15781}
15782
15783static int G__RootEventData_rootcint_460_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15784{
15785 switch (libp->paran) {
15786 case 1:
15787 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionX((const Int_t) G__int(libp->para[0])));
15788 break;
15789 case 0:
15790 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionX());
15791 break;
15792 }
15793 return(1 || funcname || hash || result7 || libp) ;
15794}
15795
15796static int G__RootEventData_rootcint_460_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15797{
15798 switch (libp->paran) {
15799 case 1:
15800 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionY((const Int_t) G__int(libp->para[0])));
15801 break;
15802 case 0:
15803 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionY());
15804 break;
15805 }
15806 return(1 || funcname || hash || result7 || libp) ;
15807}
15808
15809static int G__RootEventData_rootcint_460_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15810{
15811 switch (libp->paran) {
15812 case 1:
15813 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionZ((const Int_t) G__int(libp->para[0])));
15814 break;
15815 case 0:
15816 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionZ());
15817 break;
15818 }
15819 return(1 || funcname || hash || result7 || libp) ;
15820}
15821
15822static int G__RootEventData_rootcint_460_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15823{
15824 switch (libp->paran) {
15825 case 1:
15826 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumX((const Int_t) G__int(libp->para[0])));
15827 break;
15828 case 0:
15829 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumX());
15830 break;
15831 }
15832 return(1 || funcname || hash || result7 || libp) ;
15833}
15834
15835static int G__RootEventData_rootcint_460_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15836{
15837 switch (libp->paran) {
15838 case 1:
15839 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumY((const Int_t) G__int(libp->para[0])));
15840 break;
15841 case 0:
15842 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumY());
15843 break;
15844 }
15845 return(1 || funcname || hash || result7 || libp) ;
15846}
15847
15848static int G__RootEventData_rootcint_460_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15849{
15850 switch (libp->paran) {
15851 case 1:
15852 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumZ((const Int_t) G__int(libp->para[0])));
15853 break;
15854 case 0:
15855 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumZ());
15856 break;
15857 }
15858 return(1 || funcname || hash || result7 || libp) ;
15859}
15860
15861static int G__RootEventData_rootcint_460_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15862{
15863 switch (libp->paran) {
15864 case 1:
15865 {
15866 const TString* pobj;
15867 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetTof2VolumeName((const Int_t) G__int(libp->para[0]));
15868 pobj = new TString(xobj);
15869 result7->obj.i = (long) ((void*) pobj);
15870 result7->ref = result7->obj.i;
15871 G__store_tempobject(*result7);
15872 }
15873 break;
15874 case 0:
15875 {
15876 const TString* pobj;
15877 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetTof2VolumeName();
15878 pobj = new TString(xobj);
15879 result7->obj.i = (long) ((void*) pobj);
15880 result7->ref = result7->obj.i;
15881 G__store_tempobject(*result7);
15882 }
15883 break;
15884 }
15885 return(1 || funcname || hash || result7 || libp) ;
15886}
15887
15888static int G__RootEventData_rootcint_460_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15889{
15890 switch (libp->paran) {
15891 case 1:
15892 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTof2VolumeNumber((const Int_t) G__int(libp->para[0])));
15893 break;
15894 case 0:
15895 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTof2VolumeNumber());
15896 break;
15897 }
15898 return(1 || funcname || hash || result7 || libp) ;
15899}
15900
15901static int G__RootEventData_rootcint_460_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15902{
15903 switch (libp->paran) {
15904 case 1:
15905 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2((const Int_t) G__int(libp->para[0])));
15906 break;
15907 case 0:
15908 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2());
15909 break;
15910 }
15911 return(1 || funcname || hash || result7 || libp) ;
15912}
15913
15914static int G__RootEventData_rootcint_460_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15915{
15916 switch (libp->paran) {
15917 case 1:
15918 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2Path((const Int_t) G__int(libp->para[0])));
15919 break;
15920 case 0:
15921 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2Path());
15922 break;
15923 }
15924 return(1 || funcname || hash || result7 || libp) ;
15925}
15926
15927static int G__RootEventData_rootcint_460_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15928{
15929 switch (libp->paran) {
15930 case 1:
15931 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongZ((const Int_t) G__int(libp->para[0])));
15932 break;
15933 case 0:
15934 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongZ());
15935 break;
15936 }
15937 return(1 || funcname || hash || result7 || libp) ;
15938}
15939
15940static int G__RootEventData_rootcint_460_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15941{
15942 switch (libp->paran) {
15943 case 1:
15944 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongT((const Int_t) G__int(libp->para[0])));
15945 break;
15946 case 0:
15947 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongT());
15948 break;
15949 }
15950 return(1 || funcname || hash || result7 || libp) ;
15951}
15952
15953static int G__RootEventData_rootcint_460_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15954{
15955 switch (libp->paran) {
15956 case 1:
15957 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongX((const Int_t) G__int(libp->para[0])));
15958 break;
15959 case 0:
15960 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongX());
15961 break;
15962 }
15963 return(1 || funcname || hash || result7 || libp) ;
15964}
15965
15966static int G__RootEventData_rootcint_460_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15967{
15968 switch (libp->paran) {
15969 case 1:
15970 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongY((const Int_t) G__int(libp->para[0])));
15971 break;
15972 case 0:
15973 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongY());
15974 break;
15975 }
15976 return(1 || funcname || hash || result7 || libp) ;
15977}
15978
15979static int G__RootEventData_rootcint_460_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15980{
15981 switch (libp->paran) {
15982 case 3:
15983 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
15984, (const Int_t) G__int(libp->para[2])));
15985 break;
15986 case 2:
15987 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
15988 break;
15989 }
15990 return(1 || funcname || hash || result7 || libp) ;
15991}
15992
15993static int G__RootEventData_rootcint_460_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15994{
15995 switch (libp->paran) {
15996 case 1:
15997 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionX((const Int_t) G__int(libp->para[0])));
15998 break;
15999 case 0:
16000 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionX());
16001 break;
16002 }
16003 return(1 || funcname || hash || result7 || libp) ;
16004}
16005
16006static int G__RootEventData_rootcint_460_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16007{
16008 switch (libp->paran) {
16009 case 1:
16010 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionY((const Int_t) G__int(libp->para[0])));
16011 break;
16012 case 0:
16013 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionY());
16014 break;
16015 }
16016 return(1 || funcname || hash || result7 || libp) ;
16017}
16018
16019static int G__RootEventData_rootcint_460_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16020{
16021 switch (libp->paran) {
16022 case 1:
16023 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionZ((const Int_t) G__int(libp->para[0])));
16024 break;
16025 case 0:
16026 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionZ());
16027 break;
16028 }
16029 return(1 || funcname || hash || result7 || libp) ;
16030}
16031
16032static int G__RootEventData_rootcint_460_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16033{
16034 switch (libp->paran) {
16035 case 1:
16036 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumX((const Int_t) G__int(libp->para[0])));
16037 break;
16038 case 0:
16039 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumX());
16040 break;
16041 }
16042 return(1 || funcname || hash || result7 || libp) ;
16043}
16044
16045static int G__RootEventData_rootcint_460_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16046{
16047 switch (libp->paran) {
16048 case 1:
16049 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumY((const Int_t) G__int(libp->para[0])));
16050 break;
16051 case 0:
16052 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumY());
16053 break;
16054 }
16055 return(1 || funcname || hash || result7 || libp) ;
16056}
16057
16058static int G__RootEventData_rootcint_460_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16059{
16060 switch (libp->paran) {
16061 case 1:
16062 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumZ((const Int_t) G__int(libp->para[0])));
16063 break;
16064 case 0:
16065 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumZ());
16066 break;
16067 }
16068 return(1 || funcname || hash || result7 || libp) ;
16069}
16070
16071static int G__RootEventData_rootcint_460_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16072{
16073 switch (libp->paran) {
16074 case 1:
16075 {
16076 const TString* pobj;
16077 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetEmcVolumeName((const Int_t) G__int(libp->para[0]));
16078 pobj = new TString(xobj);
16079 result7->obj.i = (long) ((void*) pobj);
16080 result7->ref = result7->obj.i;
16081 G__store_tempobject(*result7);
16082 }
16083 break;
16084 case 0:
16085 {
16086 const TString* pobj;
16087 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetEmcVolumeName();
16088 pobj = new TString(xobj);
16089 result7->obj.i = (long) ((void*) pobj);
16090 result7->ref = result7->obj.i;
16091 G__store_tempobject(*result7);
16092 }
16093 break;
16094 }
16095 return(1 || funcname || hash || result7 || libp) ;
16096}
16097
16098static int G__RootEventData_rootcint_460_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16099{
16100 switch (libp->paran) {
16101 case 1:
16102 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetEmcVolumeNumber((const Int_t) G__int(libp->para[0])));
16103 break;
16104 case 0:
16105 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetEmcVolumeNumber());
16106 break;
16107 }
16108 return(1 || funcname || hash || result7 || libp) ;
16109}
16110
16111static int G__RootEventData_rootcint_460_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16112{
16113 switch (libp->paran) {
16114 case 1:
16115 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongTheta((const Int_t) G__int(libp->para[0])));
16116 break;
16117 case 0:
16118 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongTheta());
16119 break;
16120 }
16121 return(1 || funcname || hash || result7 || libp) ;
16122}
16123
16124static int G__RootEventData_rootcint_460_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16125{
16126 switch (libp->paran) {
16127 case 1:
16128 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongPhi((const Int_t) G__int(libp->para[0])));
16129 break;
16130 case 0:
16131 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongPhi());
16132 break;
16133 }
16134 return(1 || funcname || hash || result7 || libp) ;
16135}
16136
16137static int G__RootEventData_rootcint_460_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16138{
16139 switch (libp->paran) {
16140 case 3:
16141 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
16142, (const Int_t) G__int(libp->para[2])));
16143 break;
16144 case 2:
16145 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
16146 break;
16147 }
16148 return(1 || funcname || hash || result7 || libp) ;
16149}
16150
16151static int G__RootEventData_rootcint_460_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16152{
16153 switch (libp->paran) {
16154 case 1:
16155 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->emcPath((const Int_t) G__int(libp->para[0])));
16156 break;
16157 case 0:
16158 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->emcPath());
16159 break;
16160 }
16161 return(1 || funcname || hash || result7 || libp) ;
16162}
16163
16164static int G__RootEventData_rootcint_460_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16165{
16166 switch (libp->paran) {
16167 case 1:
16168 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionX((const Int_t) G__int(libp->para[0])));
16169 break;
16170 case 0:
16171 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionX());
16172 break;
16173 }
16174 return(1 || funcname || hash || result7 || libp) ;
16175}
16176
16177static int G__RootEventData_rootcint_460_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16178{
16179 switch (libp->paran) {
16180 case 1:
16181 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionY((const Int_t) G__int(libp->para[0])));
16182 break;
16183 case 0:
16184 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionY());
16185 break;
16186 }
16187 return(1 || funcname || hash || result7 || libp) ;
16188}
16189
16190static int G__RootEventData_rootcint_460_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16191{
16192 switch (libp->paran) {
16193 case 1:
16194 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionZ((const Int_t) G__int(libp->para[0])));
16195 break;
16196 case 0:
16197 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionZ());
16198 break;
16199 }
16200 return(1 || funcname || hash || result7 || libp) ;
16201}
16202
16203static int G__RootEventData_rootcint_460_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16204{
16205 switch (libp->paran) {
16206 case 1:
16207 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumX((const Int_t) G__int(libp->para[0])));
16208 break;
16209 case 0:
16210 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumX());
16211 break;
16212 }
16213 return(1 || funcname || hash || result7 || libp) ;
16214}
16215
16216static int G__RootEventData_rootcint_460_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16217{
16218 switch (libp->paran) {
16219 case 1:
16220 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumY((const Int_t) G__int(libp->para[0])));
16221 break;
16222 case 0:
16223 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumY());
16224 break;
16225 }
16226 return(1 || funcname || hash || result7 || libp) ;
16227}
16228
16229static int G__RootEventData_rootcint_460_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16230{
16231 switch (libp->paran) {
16232 case 1:
16233 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumZ((const Int_t) G__int(libp->para[0])));
16234 break;
16235 case 0:
16236 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumZ());
16237 break;
16238 }
16239 return(1 || funcname || hash || result7 || libp) ;
16240}
16241
16242static int G__RootEventData_rootcint_460_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16243{
16244 switch (libp->paran) {
16245 case 1:
16246 {
16247 const TString* pobj;
16248 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetMucVolumeName((const Int_t) G__int(libp->para[0]));
16249 pobj = new TString(xobj);
16250 result7->obj.i = (long) ((void*) pobj);
16251 result7->ref = result7->obj.i;
16252 G__store_tempobject(*result7);
16253 }
16254 break;
16255 case 0:
16256 {
16257 const TString* pobj;
16258 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetMucVolumeName();
16259 pobj = new TString(xobj);
16260 result7->obj.i = (long) ((void*) pobj);
16261 result7->ref = result7->obj.i;
16262 G__store_tempobject(*result7);
16263 }
16264 break;
16265 }
16266 return(1 || funcname || hash || result7 || libp) ;
16267}
16268
16269static int G__RootEventData_rootcint_460_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16270{
16271 switch (libp->paran) {
16272 case 1:
16273 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetMucVolumeNumber((const Int_t) G__int(libp->para[0])));
16274 break;
16275 case 0:
16276 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetMucVolumeNumber());
16277 break;
16278 }
16279 return(1 || funcname || hash || result7 || libp) ;
16280}
16281
16282static int G__RootEventData_rootcint_460_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16283{
16284 switch (libp->paran) {
16285 case 1:
16286 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongZ((const Int_t) G__int(libp->para[0])));
16287 break;
16288 case 0:
16289 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongZ());
16290 break;
16291 }
16292 return(1 || funcname || hash || result7 || libp) ;
16293}
16294
16295static int G__RootEventData_rootcint_460_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16296{
16297 switch (libp->paran) {
16298 case 1:
16299 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongT((const Int_t) G__int(libp->para[0])));
16300 break;
16301 case 0:
16302 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongT());
16303 break;
16304 }
16305 return(1 || funcname || hash || result7 || libp) ;
16306}
16307
16308static int G__RootEventData_rootcint_460_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16309{
16310 switch (libp->paran) {
16311 case 1:
16312 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongX((const Int_t) G__int(libp->para[0])));
16313 break;
16314 case 0:
16315 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongX());
16316 break;
16317 }
16318 return(1 || funcname || hash || result7 || libp) ;
16319}
16320
16321static int G__RootEventData_rootcint_460_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16322{
16323 switch (libp->paran) {
16324 case 1:
16325 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongY((const Int_t) G__int(libp->para[0])));
16326 break;
16327 case 0:
16328 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongY());
16329 break;
16330 }
16331 return(1 || funcname || hash || result7 || libp) ;
16332}
16333
16334static int G__RootEventData_rootcint_460_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16335{
16336 switch (libp->paran) {
16337 case 3:
16338 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
16339, (const Int_t) G__int(libp->para[2])));
16340 break;
16341 case 2:
16342 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
16343 break;
16344 }
16345 return(1 || funcname || hash || result7 || libp) ;
16346}
16347
16348static int G__RootEventData_rootcint_460_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16349{
16350 switch (libp->paran) {
16351 case 1:
16352 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetSize((const Int_t) G__int(libp->para[0])));
16353 break;
16354 case 0:
16355 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetSize());
16356 break;
16357 }
16358 return(1 || funcname || hash || result7 || libp) ;
16359}
16360
16361static int G__RootEventData_rootcint_460_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16362{
16363 switch (libp->paran) {
16364 case 2:
16365 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])));
16366 break;
16367 case 1:
16368 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionX((Int_t) G__int(libp->para[0])));
16369 break;
16370 }
16371 return(1 || funcname || hash || result7 || libp) ;
16372}
16373
16374static int G__RootEventData_rootcint_460_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16375{
16376 switch (libp->paran) {
16377 case 2:
16378 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])));
16379 break;
16380 case 1:
16381 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionY((Int_t) G__int(libp->para[0])));
16382 break;
16383 }
16384 return(1 || funcname || hash || result7 || libp) ;
16385}
16386
16387static int G__RootEventData_rootcint_460_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16388{
16389 switch (libp->paran) {
16390 case 2:
16391 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])));
16392 break;
16393 case 1:
16394 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionZ((Int_t) G__int(libp->para[0])));
16395 break;
16396 }
16397 return(1 || funcname || hash || result7 || libp) ;
16398}
16399
16400static int G__RootEventData_rootcint_460_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16401{
16402 switch (libp->paran) {
16403 case 2:
16404 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])));
16405 break;
16406 case 1:
16407 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumX((Int_t) G__int(libp->para[0])));
16408 break;
16409 }
16410 return(1 || funcname || hash || result7 || libp) ;
16411}
16412
16413static int G__RootEventData_rootcint_460_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16414{
16415 switch (libp->paran) {
16416 case 2:
16417 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])));
16418 break;
16419 case 1:
16420 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumY((Int_t) G__int(libp->para[0])));
16421 break;
16422 }
16423 return(1 || funcname || hash || result7 || libp) ;
16424}
16425
16426static int G__RootEventData_rootcint_460_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16427{
16428 switch (libp->paran) {
16429 case 2:
16430 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])));
16431 break;
16432 case 1:
16433 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumZ((Int_t) G__int(libp->para[0])));
16434 break;
16435 }
16436 return(1 || funcname || hash || result7 || libp) ;
16437}
16438
16439static int G__RootEventData_rootcint_460_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16440{
16441 switch (libp->paran) {
16442 case 2:
16443 {
16444 const TString* pobj;
16445 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetVolumeName((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
16446 pobj = new TString(xobj);
16447 result7->obj.i = (long) ((void*) pobj);
16448 result7->ref = result7->obj.i;
16449 G__store_tempobject(*result7);
16450 }
16451 break;
16452 case 1:
16453 {
16454 const TString* pobj;
16455 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetVolumeName((Int_t) G__int(libp->para[0]));
16456 pobj = new TString(xobj);
16457 result7->obj.i = (long) ((void*) pobj);
16458 result7->ref = result7->obj.i;
16459 G__store_tempobject(*result7);
16460 }
16461 break;
16462 }
16463 return(1 || funcname || hash || result7 || libp) ;
16464}
16465
16466static int G__RootEventData_rootcint_460_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16467{
16468 switch (libp->paran) {
16469 case 2:
16470 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])));
16471 break;
16472 case 1:
16473 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetVolumeNumber((Int_t) G__int(libp->para[0])));
16474 break;
16475 }
16476 return(1 || funcname || hash || result7 || libp) ;
16477}
16478
16479static int G__RootEventData_rootcint_460_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16480{
16481 switch (libp->paran) {
16482 case 2:
16483 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])));
16484 break;
16485 case 1:
16486 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongZ((Int_t) G__int(libp->para[0])));
16487 break;
16488 }
16489 return(1 || funcname || hash || result7 || libp) ;
16490}
16491
16492static int G__RootEventData_rootcint_460_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16493{
16494 switch (libp->paran) {
16495 case 2:
16496 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])));
16497 break;
16498 case 1:
16499 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongT((Int_t) G__int(libp->para[0])));
16500 break;
16501 }
16502 return(1 || funcname || hash || result7 || libp) ;
16503}
16504
16505static int G__RootEventData_rootcint_460_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16506{
16507 switch (libp->paran) {
16508 case 2:
16509 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])));
16510 break;
16511 case 1:
16512 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongX((Int_t) G__int(libp->para[0])));
16513 break;
16514 }
16515 return(1 || funcname || hash || result7 || libp) ;
16516}
16517
16518static int G__RootEventData_rootcint_460_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16519{
16520 switch (libp->paran) {
16521 case 2:
16522 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])));
16523 break;
16524 case 1:
16525 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongY((Int_t) G__int(libp->para[0])));
16526 break;
16527 }
16528 return(1 || funcname || hash || result7 || libp) ;
16529}
16530
16531static int G__RootEventData_rootcint_460_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16532{
16533 switch (libp->paran) {
16534 case 2:
16535 {
16536 const vector<Double_t>* pobj;
16537 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]));
16538 pobj = new vector<Double_t>(xobj);
16539 result7->obj.i = (long) ((void*) pobj);
16540 result7->ref = result7->obj.i;
16541 G__store_tempobject(*result7);
16542 }
16543 break;
16544 case 1:
16545 {
16546 const vector<Double_t>* pobj;
16547 const vector<Double_t> xobj = ((const TRecExtTrack*) G__getstructoffset())->GetErrorMatrix((Int_t) G__int(libp->para[0]));
16548 pobj = new vector<Double_t>(xobj);
16549 result7->obj.i = (long) ((void*) pobj);
16550 result7->ref = result7->obj.i;
16551 G__store_tempobject(*result7);
16552 }
16553 break;
16554 }
16555 return(1 || funcname || hash || result7 || libp) ;
16556}
16557
16558static int G__RootEventData_rootcint_460_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16559{
16560 G__letint(result7, 85, (long) TRecExtTrack::Class());
16561 return(1 || funcname || hash || result7 || libp) ;
16562}
16563
16564static int G__RootEventData_rootcint_460_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16565{
16566 G__letint(result7, 67, (long) TRecExtTrack::Class_Name());
16567 return(1 || funcname || hash || result7 || libp) ;
16568}
16569
16570static int G__RootEventData_rootcint_460_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16571{
16572 G__letint(result7, 115, (long) TRecExtTrack::Class_Version());
16573 return(1 || funcname || hash || result7 || libp) ;
16574}
16575
16576static int G__RootEventData_rootcint_460_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16577{
16578 TRecExtTrack::Dictionary();
16579 G__setnull(result7);
16580 return(1 || funcname || hash || result7 || libp) ;
16581}
16582
16583static int G__RootEventData_rootcint_460_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16584{
16585 ((TRecExtTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
16586 G__setnull(result7);
16587 return(1 || funcname || hash || result7 || libp) ;
16588}
16589
16590static int G__RootEventData_rootcint_460_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16591{
16592 G__letint(result7, 67, (long) TRecExtTrack::DeclFileName());
16593 return(1 || funcname || hash || result7 || libp) ;
16594}
16595
16596static int G__RootEventData_rootcint_460_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16597{
16598 G__letint(result7, 105, (long) TRecExtTrack::ImplFileLine());
16599 return(1 || funcname || hash || result7 || libp) ;
16600}
16601
16602static int G__RootEventData_rootcint_460_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16603{
16604 G__letint(result7, 67, (long) TRecExtTrack::ImplFileName());
16605 return(1 || funcname || hash || result7 || libp) ;
16606}
16607
16608static int G__RootEventData_rootcint_460_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16609{
16610 G__letint(result7, 105, (long) TRecExtTrack::DeclFileLine());
16611 return(1 || funcname || hash || result7 || libp) ;
16612}
16613
16614// automatic copy constructor
16615static int G__RootEventData_rootcint_460_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16616
16617{
16618 TRecExtTrack* p;
16619 void* tmp = (void*) G__int(libp->para[0]);
16620 p = new TRecExtTrack(*(TRecExtTrack*) tmp);
16621 result7->obj.i = (long) p;
16622 result7->ref = (long) p;
16623 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack));
16624 return(1 || funcname || hash || result7 || libp) ;
16625}
16626
16627// automatic destructor
16628typedef TRecExtTrack G__TTRecExtTrack;
16629static int G__RootEventData_rootcint_460_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16630{
16631 char* gvp = (char*) G__getgvp();
16632 long soff = G__getstructoffset();
16633 int n = G__getaryconstruct();
16634 //
16635 //has_a_delete: 1
16636 //has_own_delete1arg: 0
16637 //has_own_delete2arg: 0
16638 //
16639 if (!soff) {
16640 return(1);
16641 }
16642 if (n) {
16643 if (gvp == (char*)G__PVOID) {
16644 delete[] (TRecExtTrack*) soff;
16645 } else {
16646 G__setgvp((long) G__PVOID);
16647 for (int i = n - 1; i >= 0; --i) {
16648 ((TRecExtTrack*) (soff+(sizeof(TRecExtTrack)*i)))->~G__TTRecExtTrack();
16649 }
16650 G__setgvp((long)gvp);
16651 }
16652 } else {
16653 if (gvp == (char*)G__PVOID) {
16654 delete (TRecExtTrack*) soff;
16655 } else {
16656 G__setgvp((long) G__PVOID);
16657 ((TRecExtTrack*) (soff))->~G__TTRecExtTrack();
16658 G__setgvp((long)gvp);
16659 }
16660 }
16661 G__setnull(result7);
16662 return(1 || funcname || hash || result7 || libp) ;
16663}
16664
16665// automatic assignment operator
16666static int G__RootEventData_rootcint_460_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16667{
16668 TRecExtTrack* dest = (TRecExtTrack*) G__getstructoffset();
16669 *dest = *(TRecExtTrack*) libp->para[0].ref;
16670 const TRecExtTrack& obj = *dest;
16671 result7->ref = (long) (&obj);
16672 result7->obj.i = (long) (&obj);
16673 return(1 || funcname || hash || result7 || libp) ;
16674}
16675
16676
16677/* TRecEvTime */
16678static int G__RootEventData_rootcint_469_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16679{
16680 TRecEvTime* p = NULL;
16681 char* gvp = (char*) G__getgvp();
16682 int n = G__getaryconstruct();
16683 if (n) {
16684 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
16685 p = new TRecEvTime[n];
16686 } else {
16687 p = new((void*) gvp) TRecEvTime[n];
16688 }
16689 } else {
16690 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
16691 p = new TRecEvTime;
16692 } else {
16693 p = new((void*) gvp) TRecEvTime;
16694 }
16695 }
16696 result7->obj.i = (long) p;
16697 result7->ref = (long) p;
16698 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime));
16699 return(1 || funcname || hash || result7 || libp) ;
16700}
16701
16702static int G__RootEventData_rootcint_469_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16703{
16704 G__letint(result7, 105, (long) ((const TRecEvTime*) G__getstructoffset())->status());
16705 return(1 || funcname || hash || result7 || libp) ;
16706}
16707
16708static int G__RootEventData_rootcint_469_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16709{
16710 G__letdouble(result7, 100, (double) ((const TRecEvTime*) G__getstructoffset())->estime());
16711 return(1 || funcname || hash || result7 || libp) ;
16712}
16713
16714static int G__RootEventData_rootcint_469_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16715{
16716 G__letdouble(result7, 100, (double) ((const TRecEvTime*) G__getstructoffset())->quality());
16717 return(1 || funcname || hash || result7 || libp) ;
16718}
16719
16720static int G__RootEventData_rootcint_469_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16721{
16722 ((TRecEvTime*) G__getstructoffset())->setTest((Double_t) G__double(libp->para[0]));
16723 G__setnull(result7);
16724 return(1 || funcname || hash || result7 || libp) ;
16725}
16726
16727static int G__RootEventData_rootcint_469_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16728{
16729 ((TRecEvTime*) G__getstructoffset())->setStats((Int_t) G__int(libp->para[0]));
16730 G__setnull(result7);
16731 return(1 || funcname || hash || result7 || libp) ;
16732}
16733
16734static int G__RootEventData_rootcint_469_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16735{
16736 ((TRecEvTime*) G__getstructoffset())->setQuality((Double_t) G__double(libp->para[0]));
16737 G__setnull(result7);
16738 return(1 || funcname || hash || result7 || libp) ;
16739}
16740
16741static int G__RootEventData_rootcint_469_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16742{
16743 G__letint(result7, 85, (long) TRecEvTime::Class());
16744 return(1 || funcname || hash || result7 || libp) ;
16745}
16746
16747static int G__RootEventData_rootcint_469_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16748{
16749 G__letint(result7, 67, (long) TRecEvTime::Class_Name());
16750 return(1 || funcname || hash || result7 || libp) ;
16751}
16752
16753static int G__RootEventData_rootcint_469_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16754{
16755 G__letint(result7, 115, (long) TRecEvTime::Class_Version());
16756 return(1 || funcname || hash || result7 || libp) ;
16757}
16758
16759static int G__RootEventData_rootcint_469_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16760{
16761 TRecEvTime::Dictionary();
16762 G__setnull(result7);
16763 return(1 || funcname || hash || result7 || libp) ;
16764}
16765
16766static int G__RootEventData_rootcint_469_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16767{
16768 ((TRecEvTime*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
16769 G__setnull(result7);
16770 return(1 || funcname || hash || result7 || libp) ;
16771}
16772
16773static int G__RootEventData_rootcint_469_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16774{
16775 G__letint(result7, 67, (long) TRecEvTime::DeclFileName());
16776 return(1 || funcname || hash || result7 || libp) ;
16777}
16778
16779static int G__RootEventData_rootcint_469_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16780{
16781 G__letint(result7, 105, (long) TRecEvTime::ImplFileLine());
16782 return(1 || funcname || hash || result7 || libp) ;
16783}
16784
16785static int G__RootEventData_rootcint_469_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16786{
16787 G__letint(result7, 67, (long) TRecEvTime::ImplFileName());
16788 return(1 || funcname || hash || result7 || libp) ;
16789}
16790
16791static int G__RootEventData_rootcint_469_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16792{
16793 G__letint(result7, 105, (long) TRecEvTime::DeclFileLine());
16794 return(1 || funcname || hash || result7 || libp) ;
16795}
16796
16797// automatic copy constructor
16798static int G__RootEventData_rootcint_469_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16799
16800{
16801 TRecEvTime* p;
16802 void* tmp = (void*) G__int(libp->para[0]);
16803 p = new TRecEvTime(*(TRecEvTime*) tmp);
16804 result7->obj.i = (long) p;
16805 result7->ref = (long) p;
16806 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime));
16807 return(1 || funcname || hash || result7 || libp) ;
16808}
16809
16810// automatic destructor
16811typedef TRecEvTime G__TTRecEvTime;
16812static int G__RootEventData_rootcint_469_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16813{
16814 char* gvp = (char*) G__getgvp();
16815 long soff = G__getstructoffset();
16816 int n = G__getaryconstruct();
16817 //
16818 //has_a_delete: 1
16819 //has_own_delete1arg: 0
16820 //has_own_delete2arg: 0
16821 //
16822 if (!soff) {
16823 return(1);
16824 }
16825 if (n) {
16826 if (gvp == (char*)G__PVOID) {
16827 delete[] (TRecEvTime*) soff;
16828 } else {
16829 G__setgvp((long) G__PVOID);
16830 for (int i = n - 1; i >= 0; --i) {
16831 ((TRecEvTime*) (soff+(sizeof(TRecEvTime)*i)))->~G__TTRecEvTime();
16832 }
16833 G__setgvp((long)gvp);
16834 }
16835 } else {
16836 if (gvp == (char*)G__PVOID) {
16837 delete (TRecEvTime*) soff;
16838 } else {
16839 G__setgvp((long) G__PVOID);
16840 ((TRecEvTime*) (soff))->~G__TTRecEvTime();
16841 G__setgvp((long)gvp);
16842 }
16843 }
16844 G__setnull(result7);
16845 return(1 || funcname || hash || result7 || libp) ;
16846}
16847
16848// automatic assignment operator
16849static int G__RootEventData_rootcint_469_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16850{
16851 TRecEvTime* dest = (TRecEvTime*) G__getstructoffset();
16852 *dest = *(TRecEvTime*) libp->para[0].ref;
16853 const TRecEvTime& obj = *dest;
16854 result7->ref = (long) (&obj);
16855 result7->obj.i = (long) (&obj);
16856 return(1 || funcname || hash || result7 || libp) ;
16857}
16858
16859
16860/* TRecMdcKalHelixSeg */
16861static int G__RootEventData_rootcint_470_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16862{
16863 TRecMdcKalHelixSeg* p = NULL;
16864 char* gvp = (char*) G__getgvp();
16865 int n = G__getaryconstruct();
16866 if (n) {
16867 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
16868 p = new TRecMdcKalHelixSeg[n];
16869 } else {
16870 p = new((void*) gvp) TRecMdcKalHelixSeg[n];
16871 }
16872 } else {
16873 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
16874 p = new TRecMdcKalHelixSeg;
16875 } else {
16876 p = new((void*) gvp) TRecMdcKalHelixSeg;
16877 }
16878 }
16879 result7->obj.i = (long) p;
16880 result7->ref = (long) p;
16881 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg));
16882 return(1 || funcname || hash || result7 || libp) ;
16883}
16884
16885static int G__RootEventData_rootcint_470_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16886{
16887 G__letint(result7, 105, (long) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getTrackId());
16888 return(1 || funcname || hash || result7 || libp) ;
16889}
16890
16891static int G__RootEventData_rootcint_470_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16892{
16893 G__letint(result7, 105, (long) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getFlagLR());
16894 return(1 || funcname || hash || result7 || libp) ;
16895}
16896
16897static int G__RootEventData_rootcint_470_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16898{
16899 G__letint(result7, 104, (long) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getMdcId());
16900 return(1 || funcname || hash || result7 || libp) ;
16901}
16902
16903static int G__RootEventData_rootcint_470_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16904{
16905 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getTdc());
16906 return(1 || funcname || hash || result7 || libp) ;
16907}
16908
16909static int G__RootEventData_rootcint_470_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16910{
16911 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getAdc());
16912 return(1 || funcname || hash || result7 || libp) ;
16913}
16914
16915static int G__RootEventData_rootcint_470_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16916{
16917 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getZhit());
16918 return(1 || funcname || hash || result7 || libp) ;
16919}
16920
16921static int G__RootEventData_rootcint_470_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16922{
16923 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getTof());
16924 return(1 || funcname || hash || result7 || libp) ;
16925}
16926
16927static int G__RootEventData_rootcint_470_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16928{
16929 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getDocaIncl());
16930 return(1 || funcname || hash || result7 || libp) ;
16931}
16932
16933static int G__RootEventData_rootcint_470_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16934{
16935 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getDocaExcl());
16936 return(1 || funcname || hash || result7 || libp) ;
16937}
16938
16939static int G__RootEventData_rootcint_470_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16940{
16941 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getDD());
16942 return(1 || funcname || hash || result7 || libp) ;
16943}
16944
16945static int G__RootEventData_rootcint_470_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16946{
16947 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getEntra());
16948 return(1 || funcname || hash || result7 || libp) ;
16949}
16950
16951static int G__RootEventData_rootcint_470_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16952{
16953 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getDT());
16954 return(1 || funcname || hash || result7 || libp) ;
16955}
16956
16957static int G__RootEventData_rootcint_470_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16958{
16959 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getHelixIncl((Int_t) G__int(libp->para[0])));
16960 return(1 || funcname || hash || result7 || libp) ;
16961}
16962
16963static int G__RootEventData_rootcint_470_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16964{
16965 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getHelixExcl((Int_t) G__int(libp->para[0])));
16966 return(1 || funcname || hash || result7 || libp) ;
16967}
16968
16969static int G__RootEventData_rootcint_470_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16970{
16971 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setTrackId((Int_t) G__int(libp->para[0]));
16972 G__setnull(result7);
16973 return(1 || funcname || hash || result7 || libp) ;
16974}
16975
16976static int G__RootEventData_rootcint_470_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16977{
16978 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setFlagLR((Int_t) G__int(libp->para[0]));
16979 G__setnull(result7);
16980 return(1 || funcname || hash || result7 || libp) ;
16981}
16982
16983static int G__RootEventData_rootcint_470_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16984{
16985 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setMdcId((UInt_t) G__int(libp->para[0]));
16986 G__setnull(result7);
16987 return(1 || funcname || hash || result7 || libp) ;
16988}
16989
16990static int G__RootEventData_rootcint_470_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16991{
16992 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setTdc((Double_t) G__double(libp->para[0]));
16993 G__setnull(result7);
16994 return(1 || funcname || hash || result7 || libp) ;
16995}
16996
16997static int G__RootEventData_rootcint_470_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16998{
16999 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setAdc((Double_t) G__double(libp->para[0]));
17000 G__setnull(result7);
17001 return(1 || funcname || hash || result7 || libp) ;
17002}
17003
17004static int G__RootEventData_rootcint_470_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17005{
17006 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setZhit((Double_t) G__double(libp->para[0]));
17007 G__setnull(result7);
17008 return(1 || funcname || hash || result7 || libp) ;
17009}
17010
17011static int G__RootEventData_rootcint_470_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17012{
17013 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setTof((Double_t) G__double(libp->para[0]));
17014 G__setnull(result7);
17015 return(1 || funcname || hash || result7 || libp) ;
17016}
17017
17018static int G__RootEventData_rootcint_470_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17019{
17020 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setDocaIncl((Double_t) G__double(libp->para[0]));
17021 G__setnull(result7);
17022 return(1 || funcname || hash || result7 || libp) ;
17023}
17024
17025static int G__RootEventData_rootcint_470_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17026{
17027 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setDocaExcl((Double_t) G__double(libp->para[0]));
17028 G__setnull(result7);
17029 return(1 || funcname || hash || result7 || libp) ;
17030}
17031
17032static int G__RootEventData_rootcint_470_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17033{
17034 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setDD((Double_t) G__double(libp->para[0]));
17035 G__setnull(result7);
17036 return(1 || funcname || hash || result7 || libp) ;
17037}
17038
17039static int G__RootEventData_rootcint_470_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17040{
17041 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setEntra((Double_t) G__double(libp->para[0]));
17042 G__setnull(result7);
17043 return(1 || funcname || hash || result7 || libp) ;
17044}
17045
17046static int G__RootEventData_rootcint_470_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17047{
17048 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setDT((Double_t) G__double(libp->para[0]));
17049 G__setnull(result7);
17050 return(1 || funcname || hash || result7 || libp) ;
17051}
17052
17053static int G__RootEventData_rootcint_470_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17054{
17055 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setHelixIncl((Double_t*) G__int(libp->para[0]));
17056 G__setnull(result7);
17057 return(1 || funcname || hash || result7 || libp) ;
17058}
17059
17060static int G__RootEventData_rootcint_470_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17061{
17062 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setHelixExcl((Double_t*) G__int(libp->para[0]));
17063 G__setnull(result7);
17064 return(1 || funcname || hash || result7 || libp) ;
17065}
17066
17067static int G__RootEventData_rootcint_470_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17068{
17069 G__letint(result7, 85, (long) TRecMdcKalHelixSeg::Class());
17070 return(1 || funcname || hash || result7 || libp) ;
17071}
17072
17073static int G__RootEventData_rootcint_470_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17074{
17075 G__letint(result7, 67, (long) TRecMdcKalHelixSeg::Class_Name());
17076 return(1 || funcname || hash || result7 || libp) ;
17077}
17078
17079static int G__RootEventData_rootcint_470_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17080{
17081 G__letint(result7, 115, (long) TRecMdcKalHelixSeg::Class_Version());
17082 return(1 || funcname || hash || result7 || libp) ;
17083}
17084
17085static int G__RootEventData_rootcint_470_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17086{
17087 TRecMdcKalHelixSeg::Dictionary();
17088 G__setnull(result7);
17089 return(1 || funcname || hash || result7 || libp) ;
17090}
17091
17092static int G__RootEventData_rootcint_470_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17093{
17094 ((TRecMdcKalHelixSeg*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
17095 G__setnull(result7);
17096 return(1 || funcname || hash || result7 || libp) ;
17097}
17098
17099static int G__RootEventData_rootcint_470_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17100{
17101 G__letint(result7, 67, (long) TRecMdcKalHelixSeg::DeclFileName());
17102 return(1 || funcname || hash || result7 || libp) ;
17103}
17104
17105static int G__RootEventData_rootcint_470_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17106{
17107 G__letint(result7, 105, (long) TRecMdcKalHelixSeg::ImplFileLine());
17108 return(1 || funcname || hash || result7 || libp) ;
17109}
17110
17111static int G__RootEventData_rootcint_470_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17112{
17113 G__letint(result7, 67, (long) TRecMdcKalHelixSeg::ImplFileName());
17114 return(1 || funcname || hash || result7 || libp) ;
17115}
17116
17117static int G__RootEventData_rootcint_470_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17118{
17119 G__letint(result7, 105, (long) TRecMdcKalHelixSeg::DeclFileLine());
17120 return(1 || funcname || hash || result7 || libp) ;
17121}
17122
17123// automatic copy constructor
17124static int G__RootEventData_rootcint_470_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17125
17126{
17127 TRecMdcKalHelixSeg* p;
17128 void* tmp = (void*) G__int(libp->para[0]);
17129 p = new TRecMdcKalHelixSeg(*(TRecMdcKalHelixSeg*) tmp);
17130 result7->obj.i = (long) p;
17131 result7->ref = (long) p;
17132 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg));
17133 return(1 || funcname || hash || result7 || libp) ;
17134}
17135
17136// automatic destructor
17137typedef TRecMdcKalHelixSeg G__TTRecMdcKalHelixSeg;
17138static int G__RootEventData_rootcint_470_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17139{
17140 char* gvp = (char*) G__getgvp();
17141 long soff = G__getstructoffset();
17142 int n = G__getaryconstruct();
17143 //
17144 //has_a_delete: 1
17145 //has_own_delete1arg: 0
17146 //has_own_delete2arg: 0
17147 //
17148 if (!soff) {
17149 return(1);
17150 }
17151 if (n) {
17152 if (gvp == (char*)G__PVOID) {
17153 delete[] (TRecMdcKalHelixSeg*) soff;
17154 } else {
17155 G__setgvp((long) G__PVOID);
17156 for (int i = n - 1; i >= 0; --i) {
17157 ((TRecMdcKalHelixSeg*) (soff+(sizeof(TRecMdcKalHelixSeg)*i)))->~G__TTRecMdcKalHelixSeg();
17158 }
17159 G__setgvp((long)gvp);
17160 }
17161 } else {
17162 if (gvp == (char*)G__PVOID) {
17163 delete (TRecMdcKalHelixSeg*) soff;
17164 } else {
17165 G__setgvp((long) G__PVOID);
17166 ((TRecMdcKalHelixSeg*) (soff))->~G__TTRecMdcKalHelixSeg();
17167 G__setgvp((long)gvp);
17168 }
17169 }
17170 G__setnull(result7);
17171 return(1 || funcname || hash || result7 || libp) ;
17172}
17173
17174// automatic assignment operator
17175static int G__RootEventData_rootcint_470_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17176{
17177 TRecMdcKalHelixSeg* dest = (TRecMdcKalHelixSeg*) G__getstructoffset();
17178 *dest = *(TRecMdcKalHelixSeg*) libp->para[0].ref;
17179 const TRecMdcKalHelixSeg& obj = *dest;
17180 result7->ref = (long) (&obj);
17181 result7->obj.i = (long) (&obj);
17182 return(1 || funcname || hash || result7 || libp) ;
17183}
17184
17185
17186/* TRecZddChannel */
17187static int G__RootEventData_rootcint_471_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17188{
17189 TRecZddChannel* p = NULL;
17190 char* gvp = (char*) G__getgvp();
17191 int n = G__getaryconstruct();
17192 if (n) {
17193 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
17194 p = new TRecZddChannel[n];
17195 } else {
17196 p = new((void*) gvp) TRecZddChannel[n];
17197 }
17198 } else {
17199 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
17200 p = new TRecZddChannel;
17201 } else {
17202 p = new((void*) gvp) TRecZddChannel;
17203 }
17204 }
17205 result7->obj.i = (long) p;
17206 result7->ref = (long) p;
17207 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
17208 return(1 || funcname || hash || result7 || libp) ;
17209}
17210
17211static int G__RootEventData_rootcint_471_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17212{
17213 G__letint(result7, 105, (long) ((const TRecZddChannel*) G__getstructoffset())->channelId());
17214 return(1 || funcname || hash || result7 || libp) ;
17215}
17216
17217static int G__RootEventData_rootcint_471_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17218{
17219 G__letint(result7, 105, (long) ((const TRecZddChannel*) G__getstructoffset())->scanCode());
17220 return(1 || funcname || hash || result7 || libp) ;
17221}
17222
17223static int G__RootEventData_rootcint_471_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17224{
17225 G__letint(result7, 105, (long) ((const TRecZddChannel*) G__getstructoffset())->baseLine());
17226 return(1 || funcname || hash || result7 || libp) ;
17227}
17228
17229static int G__RootEventData_rootcint_471_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17230{
17231 G__letint(result7, 105, (long) ((const TRecZddChannel*) G__getstructoffset())->phase());
17232 return(1 || funcname || hash || result7 || libp) ;
17233}
17234
17235static int G__RootEventData_rootcint_471_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17236{
17237 {
17238 const TRecZddChannel::Fragments& obj = ((const TRecZddChannel*) G__getstructoffset())->fragments();
17239 result7->ref = (long) (&obj);
17240 result7->obj.i = (long) (&obj);
17241 }
17242 return(1 || funcname || hash || result7 || libp) ;
17243}
17244
17245static int G__RootEventData_rootcint_471_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17246{
17247 ((TRecZddChannel*) G__getstructoffset())->setChannelId((int) G__int(libp->para[0]));
17248 G__setnull(result7);
17249 return(1 || funcname || hash || result7 || libp) ;
17250}
17251
17252static int G__RootEventData_rootcint_471_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17253{
17254 ((TRecZddChannel*) G__getstructoffset())->setScanCode((int) G__int(libp->para[0]));
17255 G__setnull(result7);
17256 return(1 || funcname || hash || result7 || libp) ;
17257}
17258
17259static int G__RootEventData_rootcint_471_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17260{
17261 ((TRecZddChannel*) G__getstructoffset())->setBaseLine((int) G__int(libp->para[0]));
17262 G__setnull(result7);
17263 return(1 || funcname || hash || result7 || libp) ;
17264}
17265
17266static int G__RootEventData_rootcint_471_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17267{
17268 ((TRecZddChannel*) G__getstructoffset())->setPhase((int) G__int(libp->para[0]));
17269 G__setnull(result7);
17270 return(1 || funcname || hash || result7 || libp) ;
17271}
17272
17273static int G__RootEventData_rootcint_471_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17274{
17275 ((TRecZddChannel*) G__getstructoffset())->setFragments(*(TRecZddChannel::Fragments*) libp->para[0].ref);
17276 G__setnull(result7);
17277 return(1 || funcname || hash || result7 || libp) ;
17278}
17279
17280static int G__RootEventData_rootcint_471_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17281{
17282 G__letint(result7, 85, (long) TRecZddChannel::Class());
17283 return(1 || funcname || hash || result7 || libp) ;
17284}
17285
17286static int G__RootEventData_rootcint_471_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17287{
17288 G__letint(result7, 67, (long) TRecZddChannel::Class_Name());
17289 return(1 || funcname || hash || result7 || libp) ;
17290}
17291
17292static int G__RootEventData_rootcint_471_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17293{
17294 G__letint(result7, 115, (long) TRecZddChannel::Class_Version());
17295 return(1 || funcname || hash || result7 || libp) ;
17296}
17297
17298static int G__RootEventData_rootcint_471_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17299{
17300 TRecZddChannel::Dictionary();
17301 G__setnull(result7);
17302 return(1 || funcname || hash || result7 || libp) ;
17303}
17304
17305static int G__RootEventData_rootcint_471_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17306{
17307 ((TRecZddChannel*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
17308 G__setnull(result7);
17309 return(1 || funcname || hash || result7 || libp) ;
17310}
17311
17312static int G__RootEventData_rootcint_471_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17313{
17314 G__letint(result7, 67, (long) TRecZddChannel::DeclFileName());
17315 return(1 || funcname || hash || result7 || libp) ;
17316}
17317
17318static int G__RootEventData_rootcint_471_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17319{
17320 G__letint(result7, 105, (long) TRecZddChannel::ImplFileLine());
17321 return(1 || funcname || hash || result7 || libp) ;
17322}
17323
17324static int G__RootEventData_rootcint_471_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17325{
17326 G__letint(result7, 67, (long) TRecZddChannel::ImplFileName());
17327 return(1 || funcname || hash || result7 || libp) ;
17328}
17329
17330static int G__RootEventData_rootcint_471_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17331{
17332 G__letint(result7, 105, (long) TRecZddChannel::DeclFileLine());
17333 return(1 || funcname || hash || result7 || libp) ;
17334}
17335
17336// automatic copy constructor
17337static int G__RootEventData_rootcint_471_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17338
17339{
17340 TRecZddChannel* p;
17341 void* tmp = (void*) G__int(libp->para[0]);
17342 p = new TRecZddChannel(*(TRecZddChannel*) tmp);
17343 result7->obj.i = (long) p;
17344 result7->ref = (long) p;
17345 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
17346 return(1 || funcname || hash || result7 || libp) ;
17347}
17348
17349// automatic destructor
17350typedef TRecZddChannel G__TTRecZddChannel;
17351static int G__RootEventData_rootcint_471_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17352{
17353 char* gvp = (char*) G__getgvp();
17354 long soff = G__getstructoffset();
17355 int n = G__getaryconstruct();
17356 //
17357 //has_a_delete: 1
17358 //has_own_delete1arg: 0
17359 //has_own_delete2arg: 0
17360 //
17361 if (!soff) {
17362 return(1);
17363 }
17364 if (n) {
17365 if (gvp == (char*)G__PVOID) {
17366 delete[] (TRecZddChannel*) soff;
17367 } else {
17368 G__setgvp((long) G__PVOID);
17369 for (int i = n - 1; i >= 0; --i) {
17370 ((TRecZddChannel*) (soff+(sizeof(TRecZddChannel)*i)))->~G__TTRecZddChannel();
17371 }
17372 G__setgvp((long)gvp);
17373 }
17374 } else {
17375 if (gvp == (char*)G__PVOID) {
17376 delete (TRecZddChannel*) soff;
17377 } else {
17378 G__setgvp((long) G__PVOID);
17379 ((TRecZddChannel*) (soff))->~G__TTRecZddChannel();
17380 G__setgvp((long)gvp);
17381 }
17382 }
17383 G__setnull(result7);
17384 return(1 || funcname || hash || result7 || libp) ;
17385}
17386
17387// automatic assignment operator
17388static int G__RootEventData_rootcint_471_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17389{
17390 TRecZddChannel* dest = (TRecZddChannel*) G__getstructoffset();
17391 *dest = *(TRecZddChannel*) libp->para[0].ref;
17392 const TRecZddChannel& obj = *dest;
17393 result7->ref = (long) (&obj);
17394 result7->obj.i = (long) (&obj);
17395 return(1 || funcname || hash || result7 || libp) ;
17396}
17397
17398
17399/* TRecTrackEvent */
17400static int G__RootEventData_rootcint_477_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17401{
17402 TRecTrackEvent* p = NULL;
17403 char* gvp = (char*) G__getgvp();
17404 int n = G__getaryconstruct();
17405 if (n) {
17406 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
17407 p = new TRecTrackEvent[n];
17408 } else {
17409 p = new((void*) gvp) TRecTrackEvent[n];
17410 }
17411 } else {
17412 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
17413 p = new TRecTrackEvent;
17414 } else {
17415 p = new((void*) gvp) TRecTrackEvent;
17416 }
17417 }
17418 result7->obj.i = (long) p;
17419 result7->ref = (long) p;
17420 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent));
17421 return(1 || funcname || hash || result7 || libp) ;
17422}
17423
17424static int G__RootEventData_rootcint_477_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17425{
17426 ((TRecTrackEvent*) G__getstructoffset())->initialize();
17427 G__setnull(result7);
17428 return(1 || funcname || hash || result7 || libp) ;
17429}
17430
17431static int G__RootEventData_rootcint_477_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17432{
17433 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcTrackCol());
17434 return(1 || funcname || hash || result7 || libp) ;
17435}
17436
17437static int G__RootEventData_rootcint_477_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17438{
17439 ((TRecTrackEvent*) G__getstructoffset())->addRecMdcTrack((TRecMdcTrack*) G__int(libp->para[0]));
17440 G__setnull(result7);
17441 return(1 || funcname || hash || result7 || libp) ;
17442}
17443
17444static int G__RootEventData_rootcint_477_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17445{
17446 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcTrack((Int_t) G__int(libp->para[0])));
17447 return(1 || funcname || hash || result7 || libp) ;
17448}
17449
17450static int G__RootEventData_rootcint_477_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17451{
17452 ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcTrackCol();
17453 G__setnull(result7);
17454 return(1 || funcname || hash || result7 || libp) ;
17455}
17456
17457static int G__RootEventData_rootcint_477_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17458{
17459 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcHitCol());
17460 return(1 || funcname || hash || result7 || libp) ;
17461}
17462
17463static int G__RootEventData_rootcint_477_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17464{
17465 ((TRecTrackEvent*) G__getstructoffset())->addRecMdcHit((TRecMdcHit*) G__int(libp->para[0]));
17466 G__setnull(result7);
17467 return(1 || funcname || hash || result7 || libp) ;
17468}
17469
17470static int G__RootEventData_rootcint_477_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17471{
17472 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcHit((Int_t) G__int(libp->para[0])));
17473 return(1 || funcname || hash || result7 || libp) ;
17474}
17475
17476static int G__RootEventData_rootcint_477_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17477{
17478 ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcHitCol();
17479 G__setnull(result7);
17480 return(1 || funcname || hash || result7 || libp) ;
17481}
17482
17483static int G__RootEventData_rootcint_477_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17484{
17485 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getTofTrackCol());
17486 return(1 || funcname || hash || result7 || libp) ;
17487}
17488
17489static int G__RootEventData_rootcint_477_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17490{
17491 ((TRecTrackEvent*) G__getstructoffset())->addTofTrack((TRecTofTrack*) G__int(libp->para[0]));
17492 G__setnull(result7);
17493 return(1 || funcname || hash || result7 || libp) ;
17494}
17495
17496static int G__RootEventData_rootcint_477_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17497{
17498 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getTofTrack((Int_t) G__int(libp->para[0])));
17499 return(1 || funcname || hash || result7 || libp) ;
17500}
17501
17502static int G__RootEventData_rootcint_477_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17503{
17504 ((TRecTrackEvent*) G__getstructoffset())->clearTofTrackCol();
17505 G__setnull(result7);
17506 return(1 || funcname || hash || result7 || libp) ;
17507}
17508
17509static int G__RootEventData_rootcint_477_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17510{
17511 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcHitCol());
17512 return(1 || funcname || hash || result7 || libp) ;
17513}
17514
17515static int G__RootEventData_rootcint_477_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17516{
17517 ((TRecTrackEvent*) G__getstructoffset())->addEmcHit((TRecEmcHit*) G__int(libp->para[0]));
17518 G__setnull(result7);
17519 return(1 || funcname || hash || result7 || libp) ;
17520}
17521
17522static int G__RootEventData_rootcint_477_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17523{
17524 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcHit((Int_t) G__int(libp->para[0])));
17525 return(1 || funcname || hash || result7 || libp) ;
17526}
17527
17528static int G__RootEventData_rootcint_477_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17529{
17530 ((TRecTrackEvent*) G__getstructoffset())->clearEmcHitCol();
17531 G__setnull(result7);
17532 return(1 || funcname || hash || result7 || libp) ;
17533}
17534
17535static int G__RootEventData_rootcint_477_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17536{
17537 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcClusterCol());
17538 return(1 || funcname || hash || result7 || libp) ;
17539}
17540
17541static int G__RootEventData_rootcint_477_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17542{
17543 ((TRecTrackEvent*) G__getstructoffset())->addEmcCluster((TRecEmcCluster*) G__int(libp->para[0]));
17544 G__setnull(result7);
17545 return(1 || funcname || hash || result7 || libp) ;
17546}
17547
17548static int G__RootEventData_rootcint_477_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17549{
17550 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcCluster((Int_t) G__int(libp->para[0])));
17551 return(1 || funcname || hash || result7 || libp) ;
17552}
17553
17554static int G__RootEventData_rootcint_477_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17555{
17556 ((TRecTrackEvent*) G__getstructoffset())->clearEmcClusterCol();
17557 G__setnull(result7);
17558 return(1 || funcname || hash || result7 || libp) ;
17559}
17560
17561static int G__RootEventData_rootcint_477_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17562{
17563 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcShowerCol());
17564 return(1 || funcname || hash || result7 || libp) ;
17565}
17566
17567static int G__RootEventData_rootcint_477_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17568{
17569 ((TRecTrackEvent*) G__getstructoffset())->addEmcShower((TRecEmcShower*) G__int(libp->para[0]));
17570 G__setnull(result7);
17571 return(1 || funcname || hash || result7 || libp) ;
17572}
17573
17574static int G__RootEventData_rootcint_477_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17575{
17576 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcShower((Int_t) G__int(libp->para[0])));
17577 return(1 || funcname || hash || result7 || libp) ;
17578}
17579
17580static int G__RootEventData_rootcint_477_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17581{
17582 ((TRecTrackEvent*) G__getstructoffset())->clearEmcShowerCol();
17583 G__setnull(result7);
17584 return(1 || funcname || hash || result7 || libp) ;
17585}
17586
17587static int G__RootEventData_rootcint_477_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17588{
17589 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getMucTrackCol());
17590 return(1 || funcname || hash || result7 || libp) ;
17591}
17592
17593static int G__RootEventData_rootcint_477_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17594{
17595 ((TRecTrackEvent*) G__getstructoffset())->addMucTrack((TRecMucTrack*) G__int(libp->para[0]));
17596 G__setnull(result7);
17597 return(1 || funcname || hash || result7 || libp) ;
17598}
17599
17600static int G__RootEventData_rootcint_477_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17601{
17602 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getMucTrack((Int_t) G__int(libp->para[0])));
17603 return(1 || funcname || hash || result7 || libp) ;
17604}
17605
17606static int G__RootEventData_rootcint_477_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17607{
17608 ((TRecTrackEvent*) G__getstructoffset())->clearMucTrackCol();
17609 G__setnull(result7);
17610 return(1 || funcname || hash || result7 || libp) ;
17611}
17612
17613static int G__RootEventData_rootcint_477_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17614{
17615 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcDedxCol());
17616 return(1 || funcname || hash || result7 || libp) ;
17617}
17618
17619static int G__RootEventData_rootcint_477_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17620{
17621 ((TRecTrackEvent*) G__getstructoffset())->addRecMdcDedx((TRecMdcDedx*) G__int(libp->para[0]));
17622 G__setnull(result7);
17623 return(1 || funcname || hash || result7 || libp) ;
17624}
17625
17626static int G__RootEventData_rootcint_477_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17627{
17628 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcDedx((Int_t) G__int(libp->para[0])));
17629 return(1 || funcname || hash || result7 || libp) ;
17630}
17631
17632static int G__RootEventData_rootcint_477_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17633{
17634 ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcDedxCol();
17635 G__setnull(result7);
17636 return(1 || funcname || hash || result7 || libp) ;
17637}
17638
17639static int G__RootEventData_rootcint_477_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17640{
17641 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcDedxHitCol());
17642 return(1 || funcname || hash || result7 || libp) ;
17643}
17644
17645static int G__RootEventData_rootcint_477_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17646{
17647 ((TRecTrackEvent*) G__getstructoffset())->addRecMdcDedxHit((TRecMdcDedxHit*) G__int(libp->para[0]));
17648 G__setnull(result7);
17649 return(1 || funcname || hash || result7 || libp) ;
17650}
17651
17652static int G__RootEventData_rootcint_477_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17653{
17654 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcDedxHit((Int_t) G__int(libp->para[0])));
17655 return(1 || funcname || hash || result7 || libp) ;
17656}
17657
17658static int G__RootEventData_rootcint_477_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17659{
17660 ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcDedxHitCol();
17661 G__setnull(result7);
17662 return(1 || funcname || hash || result7 || libp) ;
17663}
17664
17665static int G__RootEventData_rootcint_477_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17666{
17667 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getExtTrackCol());
17668 return(1 || funcname || hash || result7 || libp) ;
17669}
17670
17671static int G__RootEventData_rootcint_477_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17672{
17673 ((TRecTrackEvent*) G__getstructoffset())->addExtTrack((TRecExtTrack*) G__int(libp->para[0]));
17674 G__setnull(result7);
17675 return(1 || funcname || hash || result7 || libp) ;
17676}
17677
17678static int G__RootEventData_rootcint_477_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17679{
17680 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getExtTrack((Int_t) G__int(libp->para[0])));
17681 return(1 || funcname || hash || result7 || libp) ;
17682}
17683
17684static int G__RootEventData_rootcint_477_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17685{
17686 ((TRecTrackEvent*) G__getstructoffset())->clearExtTrackCol();
17687 G__setnull(result7);
17688 return(1 || funcname || hash || result7 || libp) ;
17689}
17690
17691static int G__RootEventData_rootcint_477_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17692{
17693 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcKalTrackCol());
17694 return(1 || funcname || hash || result7 || libp) ;
17695}
17696
17697static int G__RootEventData_rootcint_477_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17698{
17699 ((TRecTrackEvent*) G__getstructoffset())->addRecMdcKalTrack((TRecMdcKalTrack*) G__int(libp->para[0]));
17700 G__setnull(result7);
17701 return(1 || funcname || hash || result7 || libp) ;
17702}
17703
17704static int G__RootEventData_rootcint_477_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17705{
17706 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcKalTrack((Int_t) G__int(libp->para[0])));
17707 return(1 || funcname || hash || result7 || libp) ;
17708}
17709
17710static int G__RootEventData_rootcint_477_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17711{
17712 ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcKalTrackCol();
17713 G__setnull(result7);
17714 return(1 || funcname || hash || result7 || libp) ;
17715}
17716
17717static int G__RootEventData_rootcint_477_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17718{
17719 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcKalHelixSegCol());
17720 return(1 || funcname || hash || result7 || libp) ;
17721}
17722
17723static int G__RootEventData_rootcint_477_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17724{
17725 ((TRecTrackEvent*) G__getstructoffset())->addRecMdcKalHelixSeg((TRecMdcKalHelixSeg*) G__int(libp->para[0]));
17726 G__setnull(result7);
17727 return(1 || funcname || hash || result7 || libp) ;
17728}
17729
17730static int G__RootEventData_rootcint_477_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17731{
17732 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcKalHelixSeg((Int_t) G__int(libp->para[0])));
17733 return(1 || funcname || hash || result7 || libp) ;
17734}
17735
17736static int G__RootEventData_rootcint_477_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17737{
17738 ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcKalHelixSegCol();
17739 G__setnull(result7);
17740 return(1 || funcname || hash || result7 || libp) ;
17741}
17742
17743static int G__RootEventData_rootcint_477_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17744{
17745 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEvTimeCol());
17746 return(1 || funcname || hash || result7 || libp) ;
17747}
17748
17749static int G__RootEventData_rootcint_477_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17750{
17751 ((TRecTrackEvent*) G__getstructoffset())->addEvTime((TRecEvTime*) G__int(libp->para[0]));
17752 G__setnull(result7);
17753 return(1 || funcname || hash || result7 || libp) ;
17754}
17755
17756static int G__RootEventData_rootcint_477_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17757{
17758 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEvTime((Int_t) G__int(libp->para[0])));
17759 return(1 || funcname || hash || result7 || libp) ;
17760}
17761
17762static int G__RootEventData_rootcint_477_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17763{
17764 ((TRecTrackEvent*) G__getstructoffset())->clearEvTimeCol();
17765 G__setnull(result7);
17766 return(1 || funcname || hash || result7 || libp) ;
17767}
17768
17769static int G__RootEventData_rootcint_477_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17770{
17771 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecZddChannelCol());
17772 return(1 || funcname || hash || result7 || libp) ;
17773}
17774
17775static int G__RootEventData_rootcint_477_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17776{
17777 ((TRecTrackEvent*) G__getstructoffset())->addRecZddChannel((TRecZddChannel*) G__int(libp->para[0]));
17778 G__setnull(result7);
17779 return(1 || funcname || hash || result7 || libp) ;
17780}
17781
17782static int G__RootEventData_rootcint_477_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17783{
17784 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecZddChannel((Int_t) G__int(libp->para[0])));
17785 return(1 || funcname || hash || result7 || libp) ;
17786}
17787
17788static int G__RootEventData_rootcint_477_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17789{
17790 ((TRecTrackEvent*) G__getstructoffset())->clearRecZddChannelCol();
17791 G__setnull(result7);
17792 return(1 || funcname || hash || result7 || libp) ;
17793}
17794
17795static int G__RootEventData_rootcint_477_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17796{
17797 G__letint(result7, 85, (long) TRecTrackEvent::Class());
17798 return(1 || funcname || hash || result7 || libp) ;
17799}
17800
17801static int G__RootEventData_rootcint_477_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17802{
17803 G__letint(result7, 67, (long) TRecTrackEvent::Class_Name());
17804 return(1 || funcname || hash || result7 || libp) ;
17805}
17806
17807static int G__RootEventData_rootcint_477_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17808{
17809 G__letint(result7, 115, (long) TRecTrackEvent::Class_Version());
17810 return(1 || funcname || hash || result7 || libp) ;
17811}
17812
17813static int G__RootEventData_rootcint_477_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17814{
17815 TRecTrackEvent::Dictionary();
17816 G__setnull(result7);
17817 return(1 || funcname || hash || result7 || libp) ;
17818}
17819
17820static int G__RootEventData_rootcint_477_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17821{
17822 ((TRecTrackEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
17823 G__setnull(result7);
17824 return(1 || funcname || hash || result7 || libp) ;
17825}
17826
17827static int G__RootEventData_rootcint_477_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17828{
17829 G__letint(result7, 67, (long) TRecTrackEvent::DeclFileName());
17830 return(1 || funcname || hash || result7 || libp) ;
17831}
17832
17833static int G__RootEventData_rootcint_477_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17834{
17835 G__letint(result7, 105, (long) TRecTrackEvent::ImplFileLine());
17836 return(1 || funcname || hash || result7 || libp) ;
17837}
17838
17839static int G__RootEventData_rootcint_477_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17840{
17841 G__letint(result7, 67, (long) TRecTrackEvent::ImplFileName());
17842 return(1 || funcname || hash || result7 || libp) ;
17843}
17844
17845static int G__RootEventData_rootcint_477_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17846{
17847 G__letint(result7, 105, (long) TRecTrackEvent::DeclFileLine());
17848 return(1 || funcname || hash || result7 || libp) ;
17849}
17850
17851// automatic copy constructor
17852static int G__RootEventData_rootcint_477_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17853
17854{
17855 TRecTrackEvent* p;
17856 void* tmp = (void*) G__int(libp->para[0]);
17857 p = new TRecTrackEvent(*(TRecTrackEvent*) tmp);
17858 result7->obj.i = (long) p;
17859 result7->ref = (long) p;
17860 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent));
17861 return(1 || funcname || hash || result7 || libp) ;
17862}
17863
17864// automatic destructor
17865typedef TRecTrackEvent G__TTRecTrackEvent;
17866static int G__RootEventData_rootcint_477_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17867{
17868 char* gvp = (char*) G__getgvp();
17869 long soff = G__getstructoffset();
17870 int n = G__getaryconstruct();
17871 //
17872 //has_a_delete: 1
17873 //has_own_delete1arg: 0
17874 //has_own_delete2arg: 0
17875 //
17876 if (!soff) {
17877 return(1);
17878 }
17879 if (n) {
17880 if (gvp == (char*)G__PVOID) {
17881 delete[] (TRecTrackEvent*) soff;
17882 } else {
17883 G__setgvp((long) G__PVOID);
17884 for (int i = n - 1; i >= 0; --i) {
17885 ((TRecTrackEvent*) (soff+(sizeof(TRecTrackEvent)*i)))->~G__TTRecTrackEvent();
17886 }
17887 G__setgvp((long)gvp);
17888 }
17889 } else {
17890 if (gvp == (char*)G__PVOID) {
17891 delete (TRecTrackEvent*) soff;
17892 } else {
17893 G__setgvp((long) G__PVOID);
17894 ((TRecTrackEvent*) (soff))->~G__TTRecTrackEvent();
17895 G__setgvp((long)gvp);
17896 }
17897 }
17898 G__setnull(result7);
17899 return(1 || funcname || hash || result7 || libp) ;
17900}
17901
17902// automatic assignment operator
17903static int G__RootEventData_rootcint_477_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17904{
17905 TRecTrackEvent* dest = (TRecTrackEvent*) G__getstructoffset();
17906 *dest = *(TRecTrackEvent*) libp->para[0].ref;
17907 const TRecTrackEvent& obj = *dest;
17908 result7->ref = (long) (&obj);
17909 result7->obj.i = (long) (&obj);
17910 return(1 || funcname || hash || result7 || libp) ;
17911}
17912
17913
17914/* TMdcTrack */
17915static int G__RootEventData_rootcint_478_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17916{
17917 TMdcTrack* p = NULL;
17918 char* gvp = (char*) G__getgvp();
17919 int n = G__getaryconstruct();
17920 if (n) {
17921 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
17922 p = new TMdcTrack[n];
17923 } else {
17924 p = new((void*) gvp) TMdcTrack[n];
17925 }
17926 } else {
17927 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
17928 p = new TMdcTrack;
17929 } else {
17930 p = new((void*) gvp) TMdcTrack;
17931 }
17932 }
17933 result7->obj.i = (long) p;
17934 result7->ref = (long) p;
17935 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack));
17936 return(1 || funcname || hash || result7 || libp) ;
17937}
17938
17939static int G__RootEventData_rootcint_478_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17940{
17941 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->trackId());
17942 return(1 || funcname || hash || result7 || libp) ;
17943}
17944
17945static int G__RootEventData_rootcint_478_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17946{
17947 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->helix((Int_t) G__int(libp->para[0])));
17948 return(1 || funcname || hash || result7 || libp) ;
17949}
17950
17951static int G__RootEventData_rootcint_478_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17952{
17953 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->stat());
17954 return(1 || funcname || hash || result7 || libp) ;
17955}
17956
17957static int G__RootEventData_rootcint_478_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17958{
17959 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->chi2());
17960 return(1 || funcname || hash || result7 || libp) ;
17961}
17962
17963static int G__RootEventData_rootcint_478_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17964{
17965 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->ndof());
17966 return(1 || funcname || hash || result7 || libp) ;
17967}
17968
17969static int G__RootEventData_rootcint_478_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17970{
17971 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->err((Int_t) G__int(libp->para[0])));
17972 return(1 || funcname || hash || result7 || libp) ;
17973}
17974
17975static int G__RootEventData_rootcint_478_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17976{
17977 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->nster());
17978 return(1 || funcname || hash || result7 || libp) ;
17979}
17980
17981static int G__RootEventData_rootcint_478_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17982{
17983 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->nlayer());
17984 return(1 || funcname || hash || result7 || libp) ;
17985}
17986
17987static int G__RootEventData_rootcint_478_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17988{
17989 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->firstLayer());
17990 return(1 || funcname || hash || result7 || libp) ;
17991}
17992
17993static int G__RootEventData_rootcint_478_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17994{
17995 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->lastLayer());
17996 return(1 || funcname || hash || result7 || libp) ;
17997}
17998
17999static int G__RootEventData_rootcint_478_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18000{
18001 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->x());
18002 return(1 || funcname || hash || result7 || libp) ;
18003}
18004
18005static int G__RootEventData_rootcint_478_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18006{
18007 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->y());
18008 return(1 || funcname || hash || result7 || libp) ;
18009}
18010
18011static int G__RootEventData_rootcint_478_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18012{
18013 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->z());
18014 return(1 || funcname || hash || result7 || libp) ;
18015}
18016
18017static int G__RootEventData_rootcint_478_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18018{
18019 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->r());
18020 return(1 || funcname || hash || result7 || libp) ;
18021}
18022
18023static int G__RootEventData_rootcint_478_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18024{
18025 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->charge());
18026 return(1 || funcname || hash || result7 || libp) ;
18027}
18028
18029static int G__RootEventData_rootcint_478_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18030{
18031 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->pxy());
18032 return(1 || funcname || hash || result7 || libp) ;
18033}
18034
18035static int G__RootEventData_rootcint_478_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18036{
18037 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->px());
18038 return(1 || funcname || hash || result7 || libp) ;
18039}
18040
18041static int G__RootEventData_rootcint_478_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18042{
18043 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->py());
18044 return(1 || funcname || hash || result7 || libp) ;
18045}
18046
18047static int G__RootEventData_rootcint_478_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18048{
18049 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->pz());
18050 return(1 || funcname || hash || result7 || libp) ;
18051}
18052
18053static int G__RootEventData_rootcint_478_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18054{
18055 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->p());
18056 return(1 || funcname || hash || result7 || libp) ;
18057}
18058
18059static int G__RootEventData_rootcint_478_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18060{
18061 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->theta());
18062 return(1 || funcname || hash || result7 || libp) ;
18063}
18064
18065static int G__RootEventData_rootcint_478_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18066{
18067 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->phi());
18068 return(1 || funcname || hash || result7 || libp) ;
18069}
18070
18071static int G__RootEventData_rootcint_478_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18072{
18073 ((TMdcTrack*) G__getstructoffset())->setHelix((Double_t*) G__int(libp->para[0]));
18074 G__setnull(result7);
18075 return(1 || funcname || hash || result7 || libp) ;
18076}
18077
18078static int G__RootEventData_rootcint_478_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18079{
18080 ((TMdcTrack*) G__getstructoffset())->setErr((Double_t*) G__int(libp->para[0]));
18081 G__setnull(result7);
18082 return(1 || funcname || hash || result7 || libp) ;
18083}
18084
18085static int G__RootEventData_rootcint_478_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18086{
18087 ((TMdcTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
18088 G__setnull(result7);
18089 return(1 || funcname || hash || result7 || libp) ;
18090}
18091
18092static int G__RootEventData_rootcint_478_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18093{
18094 ((TMdcTrack*) G__getstructoffset())->setStat((const Int_t) G__int(libp->para[0]));
18095 G__setnull(result7);
18096 return(1 || funcname || hash || result7 || libp) ;
18097}
18098
18099static int G__RootEventData_rootcint_478_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18100{
18101 ((TMdcTrack*) G__getstructoffset())->setChi2((const Double_t) G__double(libp->para[0]));
18102 G__setnull(result7);
18103 return(1 || funcname || hash || result7 || libp) ;
18104}
18105
18106static int G__RootEventData_rootcint_478_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18107{
18108 ((TMdcTrack*) G__getstructoffset())->setNdof((const Int_t) G__int(libp->para[0]));
18109 G__setnull(result7);
18110 return(1 || funcname || hash || result7 || libp) ;
18111}
18112
18113static int G__RootEventData_rootcint_478_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18114{
18115 ((TMdcTrack*) G__getstructoffset())->setNster((const Int_t) G__int(libp->para[0]));
18116 G__setnull(result7);
18117 return(1 || funcname || hash || result7 || libp) ;
18118}
18119
18120static int G__RootEventData_rootcint_478_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18121{
18122 ((TMdcTrack*) G__getstructoffset())->setNlayer((const Int_t) G__int(libp->para[0]));
18123 G__setnull(result7);
18124 return(1 || funcname || hash || result7 || libp) ;
18125}
18126
18127static int G__RootEventData_rootcint_478_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18128{
18129 ((TMdcTrack*) G__getstructoffset())->setFirstLayer((const Int_t) G__int(libp->para[0]));
18130 G__setnull(result7);
18131 return(1 || funcname || hash || result7 || libp) ;
18132}
18133
18134static int G__RootEventData_rootcint_478_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18135{
18136 ((TMdcTrack*) G__getstructoffset())->setLastLayer((const Int_t) G__int(libp->para[0]));
18137 G__setnull(result7);
18138 return(1 || funcname || hash || result7 || libp) ;
18139}
18140
18141static int G__RootEventData_rootcint_478_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18142{
18143 G__letint(result7, 85, (long) TMdcTrack::Class());
18144 return(1 || funcname || hash || result7 || libp) ;
18145}
18146
18147static int G__RootEventData_rootcint_478_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18148{
18149 G__letint(result7, 67, (long) TMdcTrack::Class_Name());
18150 return(1 || funcname || hash || result7 || libp) ;
18151}
18152
18153static int G__RootEventData_rootcint_478_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18154{
18155 G__letint(result7, 115, (long) TMdcTrack::Class_Version());
18156 return(1 || funcname || hash || result7 || libp) ;
18157}
18158
18159static int G__RootEventData_rootcint_478_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18160{
18161 TMdcTrack::Dictionary();
18162 G__setnull(result7);
18163 return(1 || funcname || hash || result7 || libp) ;
18164}
18165
18166static int G__RootEventData_rootcint_478_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18167{
18168 ((TMdcTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
18169 G__setnull(result7);
18170 return(1 || funcname || hash || result7 || libp) ;
18171}
18172
18173static int G__RootEventData_rootcint_478_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18174{
18175 G__letint(result7, 67, (long) TMdcTrack::DeclFileName());
18176 return(1 || funcname || hash || result7 || libp) ;
18177}
18178
18179static int G__RootEventData_rootcint_478_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18180{
18181 G__letint(result7, 105, (long) TMdcTrack::ImplFileLine());
18182 return(1 || funcname || hash || result7 || libp) ;
18183}
18184
18185static int G__RootEventData_rootcint_478_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18186{
18187 G__letint(result7, 67, (long) TMdcTrack::ImplFileName());
18188 return(1 || funcname || hash || result7 || libp) ;
18189}
18190
18191static int G__RootEventData_rootcint_478_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18192{
18193 G__letint(result7, 105, (long) TMdcTrack::DeclFileLine());
18194 return(1 || funcname || hash || result7 || libp) ;
18195}
18196
18197// automatic copy constructor
18198static int G__RootEventData_rootcint_478_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18199
18200{
18201 TMdcTrack* p;
18202 void* tmp = (void*) G__int(libp->para[0]);
18203 p = new TMdcTrack(*(TMdcTrack*) tmp);
18204 result7->obj.i = (long) p;
18205 result7->ref = (long) p;
18206 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack));
18207 return(1 || funcname || hash || result7 || libp) ;
18208}
18209
18210// automatic destructor
18211typedef TMdcTrack G__TTMdcTrack;
18212static int G__RootEventData_rootcint_478_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18213{
18214 char* gvp = (char*) G__getgvp();
18215 long soff = G__getstructoffset();
18216 int n = G__getaryconstruct();
18217 //
18218 //has_a_delete: 1
18219 //has_own_delete1arg: 0
18220 //has_own_delete2arg: 0
18221 //
18222 if (!soff) {
18223 return(1);
18224 }
18225 if (n) {
18226 if (gvp == (char*)G__PVOID) {
18227 delete[] (TMdcTrack*) soff;
18228 } else {
18229 G__setgvp((long) G__PVOID);
18230 for (int i = n - 1; i >= 0; --i) {
18231 ((TMdcTrack*) (soff+(sizeof(TMdcTrack)*i)))->~G__TTMdcTrack();
18232 }
18233 G__setgvp((long)gvp);
18234 }
18235 } else {
18236 if (gvp == (char*)G__PVOID) {
18237 delete (TMdcTrack*) soff;
18238 } else {
18239 G__setgvp((long) G__PVOID);
18240 ((TMdcTrack*) (soff))->~G__TTMdcTrack();
18241 G__setgvp((long)gvp);
18242 }
18243 }
18244 G__setnull(result7);
18245 return(1 || funcname || hash || result7 || libp) ;
18246}
18247
18248// automatic assignment operator
18249static int G__RootEventData_rootcint_478_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18250{
18251 TMdcTrack* dest = (TMdcTrack*) G__getstructoffset();
18252 *dest = *(TMdcTrack*) libp->para[0].ref;
18253 const TMdcTrack& obj = *dest;
18254 result7->ref = (long) (&obj);
18255 result7->obj.i = (long) (&obj);
18256 return(1 || funcname || hash || result7 || libp) ;
18257}
18258
18259
18260/* TEmcTrack */
18261static int G__RootEventData_rootcint_479_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18262{
18263 TEmcTrack* p = NULL;
18264 char* gvp = (char*) G__getgvp();
18265 int n = G__getaryconstruct();
18266 if (n) {
18267 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
18268 p = new TEmcTrack[n];
18269 } else {
18270 p = new((void*) gvp) TEmcTrack[n];
18271 }
18272 } else {
18273 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
18274 p = new TEmcTrack;
18275 } else {
18276 p = new((void*) gvp) TEmcTrack;
18277 }
18278 }
18279 result7->obj.i = (long) p;
18280 result7->ref = (long) p;
18281 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack));
18282 return(1 || funcname || hash || result7 || libp) ;
18283}
18284
18285static int G__RootEventData_rootcint_479_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18286{
18287 G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->trackId());
18288 return(1 || funcname || hash || result7 || libp) ;
18289}
18290
18291static int G__RootEventData_rootcint_479_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18292{
18293 G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->numHits());
18294 return(1 || funcname || hash || result7 || libp) ;
18295}
18296
18297static int G__RootEventData_rootcint_479_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18298{
18299 G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->status());
18300 return(1 || funcname || hash || result7 || libp) ;
18301}
18302
18303static int G__RootEventData_rootcint_479_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18304{
18305 G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->cellId());
18306 return(1 || funcname || hash || result7 || libp) ;
18307}
18308
18309static int G__RootEventData_rootcint_479_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18310{
18311 G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->module());
18312 return(1 || funcname || hash || result7 || libp) ;
18313}
18314
18315static int G__RootEventData_rootcint_479_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18316{
18317 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->x());
18318 return(1 || funcname || hash || result7 || libp) ;
18319}
18320
18321static int G__RootEventData_rootcint_479_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18322{
18323 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->y());
18324 return(1 || funcname || hash || result7 || libp) ;
18325}
18326
18327static int G__RootEventData_rootcint_479_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18328{
18329 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->z());
18330 return(1 || funcname || hash || result7 || libp) ;
18331}
18332
18333static int G__RootEventData_rootcint_479_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18334{
18335 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->theta());
18336 return(1 || funcname || hash || result7 || libp) ;
18337}
18338
18339static int G__RootEventData_rootcint_479_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18340{
18341 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->phi());
18342 return(1 || funcname || hash || result7 || libp) ;
18343}
18344
18345static int G__RootEventData_rootcint_479_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18346{
18347 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dx());
18348 return(1 || funcname || hash || result7 || libp) ;
18349}
18350
18351static int G__RootEventData_rootcint_479_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18352{
18353 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dy());
18354 return(1 || funcname || hash || result7 || libp) ;
18355}
18356
18357static int G__RootEventData_rootcint_479_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18358{
18359 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dz());
18360 return(1 || funcname || hash || result7 || libp) ;
18361}
18362
18363static int G__RootEventData_rootcint_479_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18364{
18365 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dtheta());
18366 return(1 || funcname || hash || result7 || libp) ;
18367}
18368
18369static int G__RootEventData_rootcint_479_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18370{
18371 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dphi());
18372 return(1 || funcname || hash || result7 || libp) ;
18373}
18374
18375static int G__RootEventData_rootcint_479_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18376{
18377 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->energy());
18378 return(1 || funcname || hash || result7 || libp) ;
18379}
18380
18381static int G__RootEventData_rootcint_479_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18382{
18383 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dE());
18384 return(1 || funcname || hash || result7 || libp) ;
18385}
18386
18387static int G__RootEventData_rootcint_479_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18388{
18389 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->eSeed());
18390 return(1 || funcname || hash || result7 || libp) ;
18391}
18392
18393static int G__RootEventData_rootcint_479_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18394{
18395 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->e3x3());
18396 return(1 || funcname || hash || result7 || libp) ;
18397}
18398
18399static int G__RootEventData_rootcint_479_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18400{
18401 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->e5x5());
18402 return(1 || funcname || hash || result7 || libp) ;
18403}
18404
18405static int G__RootEventData_rootcint_479_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18406{
18407 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->time());
18408 return(1 || funcname || hash || result7 || libp) ;
18409}
18410
18411static int G__RootEventData_rootcint_479_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18412{
18413 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->secondMoment());
18414 return(1 || funcname || hash || result7 || libp) ;
18415}
18416
18417static int G__RootEventData_rootcint_479_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18418{
18419 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->latMoment());
18420 return(1 || funcname || hash || result7 || libp) ;
18421}
18422
18423static int G__RootEventData_rootcint_479_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18424{
18425 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->a20Moment());
18426 return(1 || funcname || hash || result7 || libp) ;
18427}
18428
18429static int G__RootEventData_rootcint_479_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18430{
18431 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->a42Moment());
18432 return(1 || funcname || hash || result7 || libp) ;
18433}
18434
18435static int G__RootEventData_rootcint_479_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18436{
18437 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->err((Int_t) G__int(libp->para[0])));
18438 return(1 || funcname || hash || result7 || libp) ;
18439}
18440
18441static int G__RootEventData_rootcint_479_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18442{
18443 ((TEmcTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
18444 G__setnull(result7);
18445 return(1 || funcname || hash || result7 || libp) ;
18446}
18447
18448static int G__RootEventData_rootcint_479_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18449{
18450 ((TEmcTrack*) G__getstructoffset())->setNumHits((const Int_t) G__int(libp->para[0]));
18451 G__setnull(result7);
18452 return(1 || funcname || hash || result7 || libp) ;
18453}
18454
18455static int G__RootEventData_rootcint_479_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18456{
18457 ((TEmcTrack*) G__getstructoffset())->setStatus((const Int_t) G__int(libp->para[0]));
18458 G__setnull(result7);
18459 return(1 || funcname || hash || result7 || libp) ;
18460}
18461
18462static int G__RootEventData_rootcint_479_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18463{
18464 ((TEmcTrack*) G__getstructoffset())->setCellId((const Int_t) G__int(libp->para[0]));
18465 G__setnull(result7);
18466 return(1 || funcname || hash || result7 || libp) ;
18467}
18468
18469static int G__RootEventData_rootcint_479_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18470{
18471 ((TEmcTrack*) G__getstructoffset())->setModule((const Int_t) G__int(libp->para[0]));
18472 G__setnull(result7);
18473 return(1 || funcname || hash || result7 || libp) ;
18474}
18475
18476static int G__RootEventData_rootcint_479_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18477{
18478 ((TEmcTrack*) G__getstructoffset())->setX((const Double_t) G__double(libp->para[0]));
18479 G__setnull(result7);
18480 return(1 || funcname || hash || result7 || libp) ;
18481}
18482
18483static int G__RootEventData_rootcint_479_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18484{
18485 ((TEmcTrack*) G__getstructoffset())->setY((const Double_t) G__double(libp->para[0]));
18486 G__setnull(result7);
18487 return(1 || funcname || hash || result7 || libp) ;
18488}
18489
18490static int G__RootEventData_rootcint_479_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18491{
18492 ((TEmcTrack*) G__getstructoffset())->setZ((const Double_t) G__double(libp->para[0]));
18493 G__setnull(result7);
18494 return(1 || funcname || hash || result7 || libp) ;
18495}
18496
18497static int G__RootEventData_rootcint_479_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18498{
18499 ((TEmcTrack*) G__getstructoffset())->setEnergy((const Double_t) G__double(libp->para[0]));
18500 G__setnull(result7);
18501 return(1 || funcname || hash || result7 || libp) ;
18502}
18503
18504static int G__RootEventData_rootcint_479_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18505{
18506 ((TEmcTrack*) G__getstructoffset())->setDE((const Double_t) G__double(libp->para[0]));
18507 G__setnull(result7);
18508 return(1 || funcname || hash || result7 || libp) ;
18509}
18510
18511static int G__RootEventData_rootcint_479_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18512{
18513 ((TEmcTrack*) G__getstructoffset())->setDtheta((const Double_t) G__double(libp->para[0]));
18514 G__setnull(result7);
18515 return(1 || funcname || hash || result7 || libp) ;
18516}
18517
18518static int G__RootEventData_rootcint_479_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18519{
18520 ((TEmcTrack*) G__getstructoffset())->setDphi((const Double_t) G__double(libp->para[0]));
18521 G__setnull(result7);
18522 return(1 || funcname || hash || result7 || libp) ;
18523}
18524
18525static int G__RootEventData_rootcint_479_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18526{
18527 ((TEmcTrack*) G__getstructoffset())->setESeed((const Double_t) G__double(libp->para[0]));
18528 G__setnull(result7);
18529 return(1 || funcname || hash || result7 || libp) ;
18530}
18531
18532static int G__RootEventData_rootcint_479_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18533{
18534 ((TEmcTrack*) G__getstructoffset())->setE3x3((const Double_t) G__double(libp->para[0]));
18535 G__setnull(result7);
18536 return(1 || funcname || hash || result7 || libp) ;
18537}
18538
18539static int G__RootEventData_rootcint_479_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18540{
18541 ((TEmcTrack*) G__getstructoffset())->setE5x5((const Double_t) G__double(libp->para[0]));
18542 G__setnull(result7);
18543 return(1 || funcname || hash || result7 || libp) ;
18544}
18545
18546static int G__RootEventData_rootcint_479_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18547{
18548 ((TEmcTrack*) G__getstructoffset())->setTime((const Double_t) G__double(libp->para[0]));
18549 G__setnull(result7);
18550 return(1 || funcname || hash || result7 || libp) ;
18551}
18552
18553static int G__RootEventData_rootcint_479_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18554{
18555 ((TEmcTrack*) G__getstructoffset())->setSecondMoment((const Double_t) G__double(libp->para[0]));
18556 G__setnull(result7);
18557 return(1 || funcname || hash || result7 || libp) ;
18558}
18559
18560static int G__RootEventData_rootcint_479_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18561{
18562 ((TEmcTrack*) G__getstructoffset())->setLatMoment((const Double_t) G__double(libp->para[0]));
18563 G__setnull(result7);
18564 return(1 || funcname || hash || result7 || libp) ;
18565}
18566
18567static int G__RootEventData_rootcint_479_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18568{
18569 ((TEmcTrack*) G__getstructoffset())->setA20Moment((const Double_t) G__double(libp->para[0]));
18570 G__setnull(result7);
18571 return(1 || funcname || hash || result7 || libp) ;
18572}
18573
18574static int G__RootEventData_rootcint_479_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18575{
18576 ((TEmcTrack*) G__getstructoffset())->setA42Moment((const Double_t) G__double(libp->para[0]));
18577 G__setnull(result7);
18578 return(1 || funcname || hash || result7 || libp) ;
18579}
18580
18581static int G__RootEventData_rootcint_479_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18582{
18583 ((TEmcTrack*) G__getstructoffset())->setErr((Double_t*) G__int(libp->para[0]));
18584 G__setnull(result7);
18585 return(1 || funcname || hash || result7 || libp) ;
18586}
18587
18588static int G__RootEventData_rootcint_479_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18589{
18590 G__letint(result7, 85, (long) TEmcTrack::Class());
18591 return(1 || funcname || hash || result7 || libp) ;
18592}
18593
18594static int G__RootEventData_rootcint_479_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18595{
18596 G__letint(result7, 67, (long) TEmcTrack::Class_Name());
18597 return(1 || funcname || hash || result7 || libp) ;
18598}
18599
18600static int G__RootEventData_rootcint_479_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18601{
18602 G__letint(result7, 115, (long) TEmcTrack::Class_Version());
18603 return(1 || funcname || hash || result7 || libp) ;
18604}
18605
18606static int G__RootEventData_rootcint_479_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18607{
18608 TEmcTrack::Dictionary();
18609 G__setnull(result7);
18610 return(1 || funcname || hash || result7 || libp) ;
18611}
18612
18613static int G__RootEventData_rootcint_479_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18614{
18615 ((TEmcTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
18616 G__setnull(result7);
18617 return(1 || funcname || hash || result7 || libp) ;
18618}
18619
18620static int G__RootEventData_rootcint_479_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18621{
18622 G__letint(result7, 67, (long) TEmcTrack::DeclFileName());
18623 return(1 || funcname || hash || result7 || libp) ;
18624}
18625
18626static int G__RootEventData_rootcint_479_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18627{
18628 G__letint(result7, 105, (long) TEmcTrack::ImplFileLine());
18629 return(1 || funcname || hash || result7 || libp) ;
18630}
18631
18632static int G__RootEventData_rootcint_479_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18633{
18634 G__letint(result7, 67, (long) TEmcTrack::ImplFileName());
18635 return(1 || funcname || hash || result7 || libp) ;
18636}
18637
18638static int G__RootEventData_rootcint_479_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18639{
18640 G__letint(result7, 105, (long) TEmcTrack::DeclFileLine());
18641 return(1 || funcname || hash || result7 || libp) ;
18642}
18643
18644// automatic copy constructor
18645static int G__RootEventData_rootcint_479_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18646
18647{
18648 TEmcTrack* p;
18649 void* tmp = (void*) G__int(libp->para[0]);
18650 p = new TEmcTrack(*(TEmcTrack*) tmp);
18651 result7->obj.i = (long) p;
18652 result7->ref = (long) p;
18653 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack));
18654 return(1 || funcname || hash || result7 || libp) ;
18655}
18656
18657// automatic destructor
18658typedef TEmcTrack G__TTEmcTrack;
18659static int G__RootEventData_rootcint_479_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18660{
18661 char* gvp = (char*) G__getgvp();
18662 long soff = G__getstructoffset();
18663 int n = G__getaryconstruct();
18664 //
18665 //has_a_delete: 1
18666 //has_own_delete1arg: 0
18667 //has_own_delete2arg: 0
18668 //
18669 if (!soff) {
18670 return(1);
18671 }
18672 if (n) {
18673 if (gvp == (char*)G__PVOID) {
18674 delete[] (TEmcTrack*) soff;
18675 } else {
18676 G__setgvp((long) G__PVOID);
18677 for (int i = n - 1; i >= 0; --i) {
18678 ((TEmcTrack*) (soff+(sizeof(TEmcTrack)*i)))->~G__TTEmcTrack();
18679 }
18680 G__setgvp((long)gvp);
18681 }
18682 } else {
18683 if (gvp == (char*)G__PVOID) {
18684 delete (TEmcTrack*) soff;
18685 } else {
18686 G__setgvp((long) G__PVOID);
18687 ((TEmcTrack*) (soff))->~G__TTEmcTrack();
18688 G__setgvp((long)gvp);
18689 }
18690 }
18691 G__setnull(result7);
18692 return(1 || funcname || hash || result7 || libp) ;
18693}
18694
18695// automatic assignment operator
18696static int G__RootEventData_rootcint_479_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18697{
18698 TEmcTrack* dest = (TEmcTrack*) G__getstructoffset();
18699 *dest = *(TEmcTrack*) libp->para[0].ref;
18700 const TEmcTrack& obj = *dest;
18701 result7->ref = (long) (&obj);
18702 result7->obj.i = (long) (&obj);
18703 return(1 || funcname || hash || result7 || libp) ;
18704}
18705
18706
18707/* TMucTrack */
18708static int G__RootEventData_rootcint_480_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18709{
18710 TMucTrack* p = NULL;
18711 char* gvp = (char*) G__getgvp();
18712 int n = G__getaryconstruct();
18713 if (n) {
18714 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
18715 p = new TMucTrack[n];
18716 } else {
18717 p = new((void*) gvp) TMucTrack[n];
18718 }
18719 } else {
18720 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
18721 p = new TMucTrack;
18722 } else {
18723 p = new((void*) gvp) TMucTrack;
18724 }
18725 }
18726 result7->obj.i = (long) p;
18727 result7->ref = (long) p;
18728 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack));
18729 return(1 || funcname || hash || result7 || libp) ;
18730}
18731
18732static int G__RootEventData_rootcint_480_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18733{
18734 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->trackId());
18735 return(1 || funcname || hash || result7 || libp) ;
18736}
18737
18738static int G__RootEventData_rootcint_480_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18739{
18740 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->id());
18741 return(1 || funcname || hash || result7 || libp) ;
18742}
18743
18744static int G__RootEventData_rootcint_480_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18745{
18746 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->status());
18747 return(1 || funcname || hash || result7 || libp) ;
18748}
18749
18750static int G__RootEventData_rootcint_480_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18751{
18752 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->type());
18753 return(1 || funcname || hash || result7 || libp) ;
18754}
18755
18756static int G__RootEventData_rootcint_480_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18757{
18758 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->startPart());
18759 return(1 || funcname || hash || result7 || libp) ;
18760}
18761
18762static int G__RootEventData_rootcint_480_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18763{
18764 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->endPart());
18765 return(1 || funcname || hash || result7 || libp) ;
18766}
18767
18768static int G__RootEventData_rootcint_480_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18769{
18770 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->brLastLayer());
18771 return(1 || funcname || hash || result7 || libp) ;
18772}
18773
18774static int G__RootEventData_rootcint_480_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18775{
18776 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->ecLastLayer());
18777 return(1 || funcname || hash || result7 || libp) ;
18778}
18779
18780static int G__RootEventData_rootcint_480_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18781{
18782 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->numHits());
18783 return(1 || funcname || hash || result7 || libp) ;
18784}
18785
18786static int G__RootEventData_rootcint_480_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18787{
18788 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->numLayers());
18789 return(1 || funcname || hash || result7 || libp) ;
18790}
18791
18792static int G__RootEventData_rootcint_480_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18793{
18794 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->maxHitsInLayer());
18795 return(1 || funcname || hash || result7 || libp) ;
18796}
18797
18798static int G__RootEventData_rootcint_480_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18799{
18800 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->depth());
18801 return(1 || funcname || hash || result7 || libp) ;
18802}
18803
18804static int G__RootEventData_rootcint_480_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18805{
18806 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->chi2());
18807 return(1 || funcname || hash || result7 || libp) ;
18808}
18809
18810static int G__RootEventData_rootcint_480_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18811{
18812 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->dof());
18813 return(1 || funcname || hash || result7 || libp) ;
18814}
18815
18816static int G__RootEventData_rootcint_480_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18817{
18818 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->rms());
18819 return(1 || funcname || hash || result7 || libp) ;
18820}
18821
18822static int G__RootEventData_rootcint_480_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18823{
18824 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->xPos());
18825 return(1 || funcname || hash || result7 || libp) ;
18826}
18827
18828static int G__RootEventData_rootcint_480_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18829{
18830 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->yPos());
18831 return(1 || funcname || hash || result7 || libp) ;
18832}
18833
18834static int G__RootEventData_rootcint_480_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18835{
18836 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->zPos());
18837 return(1 || funcname || hash || result7 || libp) ;
18838}
18839
18840static int G__RootEventData_rootcint_480_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18841{
18842 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->xPosSigma());
18843 return(1 || funcname || hash || result7 || libp) ;
18844}
18845
18846static int G__RootEventData_rootcint_480_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18847{
18848 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->yPosSigma());
18849 return(1 || funcname || hash || result7 || libp) ;
18850}
18851
18852static int G__RootEventData_rootcint_480_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18853{
18854 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->zPosSigma());
18855 return(1 || funcname || hash || result7 || libp) ;
18856}
18857
18858static int G__RootEventData_rootcint_480_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18859{
18860 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->px());
18861 return(1 || funcname || hash || result7 || libp) ;
18862}
18863
18864static int G__RootEventData_rootcint_480_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18865{
18866 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->py());
18867 return(1 || funcname || hash || result7 || libp) ;
18868}
18869
18870static int G__RootEventData_rootcint_480_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18871{
18872 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->pz());
18873 return(1 || funcname || hash || result7 || libp) ;
18874}
18875
18876static int G__RootEventData_rootcint_480_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18877{
18878 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->distance());
18879 return(1 || funcname || hash || result7 || libp) ;
18880}
18881
18882static int G__RootEventData_rootcint_480_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18883{
18884 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->deltaPhi());
18885 return(1 || funcname || hash || result7 || libp) ;
18886}
18887
18888static int G__RootEventData_rootcint_480_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18889{
18890 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->kalRechi2());
18891 return(1 || funcname || hash || result7 || libp) ;
18892}
18893
18894static int G__RootEventData_rootcint_480_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18895{
18896 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->kaldof());
18897 return(1 || funcname || hash || result7 || libp) ;
18898}
18899
18900static int G__RootEventData_rootcint_480_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18901{
18902 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->kaldepth());
18903 return(1 || funcname || hash || result7 || libp) ;
18904}
18905
18906static int G__RootEventData_rootcint_480_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18907{
18908 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->kalbrLastLayer());
18909 return(1 || funcname || hash || result7 || libp) ;
18910}
18911
18912static int G__RootEventData_rootcint_480_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18913{
18914 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->kalecLastLayer());
18915 return(1 || funcname || hash || result7 || libp) ;
18916}
18917
18918static int G__RootEventData_rootcint_480_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18919{
18920 ((TMucTrack*) G__getstructoffset())->setTrackId((Int_t) G__int(libp->para[0]));
18921 G__setnull(result7);
18922 return(1 || funcname || hash || result7 || libp) ;
18923}
18924
18925static int G__RootEventData_rootcint_480_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18926{
18927 ((TMucTrack*) G__getstructoffset())->setId((Int_t) G__int(libp->para[0]));
18928 G__setnull(result7);
18929 return(1 || funcname || hash || result7 || libp) ;
18930}
18931
18932static int G__RootEventData_rootcint_480_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18933{
18934 ((TMucTrack*) G__getstructoffset())->setStatus((Int_t) G__int(libp->para[0]));
18935 G__setnull(result7);
18936 return(1 || funcname || hash || result7 || libp) ;
18937}
18938
18939static int G__RootEventData_rootcint_480_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18940{
18941 ((TMucTrack*) G__getstructoffset())->setType((Int_t) G__int(libp->para[0]));
18942 G__setnull(result7);
18943 return(1 || funcname || hash || result7 || libp) ;
18944}
18945
18946static int G__RootEventData_rootcint_480_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18947{
18948 ((TMucTrack*) G__getstructoffset())->setStartPart((Int_t) G__int(libp->para[0]));
18949 G__setnull(result7);
18950 return(1 || funcname || hash || result7 || libp) ;
18951}
18952
18953static int G__RootEventData_rootcint_480_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18954{
18955 ((TMucTrack*) G__getstructoffset())->setEndPart((Int_t) G__int(libp->para[0]));
18956 G__setnull(result7);
18957 return(1 || funcname || hash || result7 || libp) ;
18958}
18959
18960static int G__RootEventData_rootcint_480_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18961{
18962 ((TMucTrack*) G__getstructoffset())->setBrLastLayer((Int_t) G__int(libp->para[0]));
18963 G__setnull(result7);
18964 return(1 || funcname || hash || result7 || libp) ;
18965}
18966
18967static int G__RootEventData_rootcint_480_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18968{
18969 ((TMucTrack*) G__getstructoffset())->setEcLastLayer((Int_t) G__int(libp->para[0]));
18970 G__setnull(result7);
18971 return(1 || funcname || hash || result7 || libp) ;
18972}
18973
18974static int G__RootEventData_rootcint_480_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18975{
18976 ((TMucTrack*) G__getstructoffset())->setNumHits((Int_t) G__int(libp->para[0]));
18977 G__setnull(result7);
18978 return(1 || funcname || hash || result7 || libp) ;
18979}
18980
18981static int G__RootEventData_rootcint_480_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18982{
18983 ((TMucTrack*) G__getstructoffset())->setNumLayers((Int_t) G__int(libp->para[0]));
18984 G__setnull(result7);
18985 return(1 || funcname || hash || result7 || libp) ;
18986}
18987
18988static int G__RootEventData_rootcint_480_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18989{
18990 ((TMucTrack*) G__getstructoffset())->setMaxHitsInLayer((Int_t) G__int(libp->para[0]));
18991 G__setnull(result7);
18992 return(1 || funcname || hash || result7 || libp) ;
18993}
18994
18995static int G__RootEventData_rootcint_480_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18996{
18997 ((TMucTrack*) G__getstructoffset())->setDepth((Double_t) G__double(libp->para[0]));
18998 G__setnull(result7);
18999 return(1 || funcname || hash || result7 || libp) ;
19000}
19001
19002static int G__RootEventData_rootcint_480_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19003{
19004 ((TMucTrack*) G__getstructoffset())->setChi2((Double_t) G__double(libp->para[0]));
19005 G__setnull(result7);
19006 return(1 || funcname || hash || result7 || libp) ;
19007}
19008
19009static int G__RootEventData_rootcint_480_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19010{
19011 ((TMucTrack*) G__getstructoffset())->setDof((Int_t) G__int(libp->para[0]));
19012 G__setnull(result7);
19013 return(1 || funcname || hash || result7 || libp) ;
19014}
19015
19016static int G__RootEventData_rootcint_480_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19017{
19018 ((TMucTrack*) G__getstructoffset())->setRms((Double_t) G__double(libp->para[0]));
19019 G__setnull(result7);
19020 return(1 || funcname || hash || result7 || libp) ;
19021}
19022
19023static int G__RootEventData_rootcint_480_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19024{
19025 ((TMucTrack*) G__getstructoffset())->setXPos((Double_t) G__double(libp->para[0]));
19026 G__setnull(result7);
19027 return(1 || funcname || hash || result7 || libp) ;
19028}
19029
19030static int G__RootEventData_rootcint_480_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19031{
19032 ((TMucTrack*) G__getstructoffset())->setYPos((Double_t) G__double(libp->para[0]));
19033 G__setnull(result7);
19034 return(1 || funcname || hash || result7 || libp) ;
19035}
19036
19037static int G__RootEventData_rootcint_480_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19038{
19039 ((TMucTrack*) G__getstructoffset())->setZPos((Double_t) G__double(libp->para[0]));
19040 G__setnull(result7);
19041 return(1 || funcname || hash || result7 || libp) ;
19042}
19043
19044static int G__RootEventData_rootcint_480_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19045{
19046 ((TMucTrack*) G__getstructoffset())->setXPosSigma((Double_t) G__double(libp->para[0]));
19047 G__setnull(result7);
19048 return(1 || funcname || hash || result7 || libp) ;
19049}
19050
19051static int G__RootEventData_rootcint_480_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19052{
19053 ((TMucTrack*) G__getstructoffset())->setYPosSigma((Double_t) G__double(libp->para[0]));
19054 G__setnull(result7);
19055 return(1 || funcname || hash || result7 || libp) ;
19056}
19057
19058static int G__RootEventData_rootcint_480_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19059{
19060 ((TMucTrack*) G__getstructoffset())->setZPosSigma((Double_t) G__double(libp->para[0]));
19061 G__setnull(result7);
19062 return(1 || funcname || hash || result7 || libp) ;
19063}
19064
19065static int G__RootEventData_rootcint_480_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19066{
19067 ((TMucTrack*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
19068 G__setnull(result7);
19069 return(1 || funcname || hash || result7 || libp) ;
19070}
19071
19072static int G__RootEventData_rootcint_480_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19073{
19074 ((TMucTrack*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
19075 G__setnull(result7);
19076 return(1 || funcname || hash || result7 || libp) ;
19077}
19078
19079static int G__RootEventData_rootcint_480_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19080{
19081 ((TMucTrack*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
19082 G__setnull(result7);
19083 return(1 || funcname || hash || result7 || libp) ;
19084}
19085
19086static int G__RootEventData_rootcint_480_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19087{
19088 ((TMucTrack*) G__getstructoffset())->setDistance((double) G__double(libp->para[0]));
19089 G__setnull(result7);
19090 return(1 || funcname || hash || result7 || libp) ;
19091}
19092
19093static int G__RootEventData_rootcint_480_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19094{
19095 ((TMucTrack*) G__getstructoffset())->setDeltaPhi((double) G__double(libp->para[0]));
19096 G__setnull(result7);
19097 return(1 || funcname || hash || result7 || libp) ;
19098}
19099
19100static int G__RootEventData_rootcint_480_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19101{
19102 ((TMucTrack*) G__getstructoffset())->setkalRechi2((Double_t) G__double(libp->para[0]));
19103 G__setnull(result7);
19104 return(1 || funcname || hash || result7 || libp) ;
19105}
19106
19107static int G__RootEventData_rootcint_480_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19108{
19109 ((TMucTrack*) G__getstructoffset())->setkalDof((Int_t) G__int(libp->para[0]));
19110 G__setnull(result7);
19111 return(1 || funcname || hash || result7 || libp) ;
19112}
19113
19114static int G__RootEventData_rootcint_480_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19115{
19116 ((TMucTrack*) G__getstructoffset())->setkalDepth((Double_t) G__double(libp->para[0]));
19117 G__setnull(result7);
19118 return(1 || funcname || hash || result7 || libp) ;
19119}
19120
19121static int G__RootEventData_rootcint_480_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19122{
19123 ((TMucTrack*) G__getstructoffset())->setkalbrLastLayer((Int_t) G__int(libp->para[0]));
19124 G__setnull(result7);
19125 return(1 || funcname || hash || result7 || libp) ;
19126}
19127
19128static int G__RootEventData_rootcint_480_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19129{
19130 ((TMucTrack*) G__getstructoffset())->setkalecLastLayer((Int_t) G__int(libp->para[0]));
19131 G__setnull(result7);
19132 return(1 || funcname || hash || result7 || libp) ;
19133}
19134
19135static int G__RootEventData_rootcint_480_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19136{
19137 G__letint(result7, 85, (long) TMucTrack::Class());
19138 return(1 || funcname || hash || result7 || libp) ;
19139}
19140
19141static int G__RootEventData_rootcint_480_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19142{
19143 G__letint(result7, 67, (long) TMucTrack::Class_Name());
19144 return(1 || funcname || hash || result7 || libp) ;
19145}
19146
19147static int G__RootEventData_rootcint_480_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19148{
19149 G__letint(result7, 115, (long) TMucTrack::Class_Version());
19150 return(1 || funcname || hash || result7 || libp) ;
19151}
19152
19153static int G__RootEventData_rootcint_480_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19154{
19155 TMucTrack::Dictionary();
19156 G__setnull(result7);
19157 return(1 || funcname || hash || result7 || libp) ;
19158}
19159
19160static int G__RootEventData_rootcint_480_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19161{
19162 ((TMucTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
19163 G__setnull(result7);
19164 return(1 || funcname || hash || result7 || libp) ;
19165}
19166
19167static int G__RootEventData_rootcint_480_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19168{
19169 G__letint(result7, 67, (long) TMucTrack::DeclFileName());
19170 return(1 || funcname || hash || result7 || libp) ;
19171}
19172
19173static int G__RootEventData_rootcint_480_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19174{
19175 G__letint(result7, 105, (long) TMucTrack::ImplFileLine());
19176 return(1 || funcname || hash || result7 || libp) ;
19177}
19178
19179static int G__RootEventData_rootcint_480_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19180{
19181 G__letint(result7, 67, (long) TMucTrack::ImplFileName());
19182 return(1 || funcname || hash || result7 || libp) ;
19183}
19184
19185static int G__RootEventData_rootcint_480_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19186{
19187 G__letint(result7, 105, (long) TMucTrack::DeclFileLine());
19188 return(1 || funcname || hash || result7 || libp) ;
19189}
19190
19191// automatic copy constructor
19192static int G__RootEventData_rootcint_480_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19193
19194{
19195 TMucTrack* p;
19196 void* tmp = (void*) G__int(libp->para[0]);
19197 p = new TMucTrack(*(TMucTrack*) tmp);
19198 result7->obj.i = (long) p;
19199 result7->ref = (long) p;
19200 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack));
19201 return(1 || funcname || hash || result7 || libp) ;
19202}
19203
19204// automatic destructor
19205typedef TMucTrack G__TTMucTrack;
19206static int G__RootEventData_rootcint_480_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19207{
19208 char* gvp = (char*) G__getgvp();
19209 long soff = G__getstructoffset();
19210 int n = G__getaryconstruct();
19211 //
19212 //has_a_delete: 1
19213 //has_own_delete1arg: 0
19214 //has_own_delete2arg: 0
19215 //
19216 if (!soff) {
19217 return(1);
19218 }
19219 if (n) {
19220 if (gvp == (char*)G__PVOID) {
19221 delete[] (TMucTrack*) soff;
19222 } else {
19223 G__setgvp((long) G__PVOID);
19224 for (int i = n - 1; i >= 0; --i) {
19225 ((TMucTrack*) (soff+(sizeof(TMucTrack)*i)))->~G__TTMucTrack();
19226 }
19227 G__setgvp((long)gvp);
19228 }
19229 } else {
19230 if (gvp == (char*)G__PVOID) {
19231 delete (TMucTrack*) soff;
19232 } else {
19233 G__setgvp((long) G__PVOID);
19234 ((TMucTrack*) (soff))->~G__TTMucTrack();
19235 G__setgvp((long)gvp);
19236 }
19237 }
19238 G__setnull(result7);
19239 return(1 || funcname || hash || result7 || libp) ;
19240}
19241
19242// automatic assignment operator
19243static int G__RootEventData_rootcint_480_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19244{
19245 TMucTrack* dest = (TMucTrack*) G__getstructoffset();
19246 *dest = *(TMucTrack*) libp->para[0].ref;
19247 const TMucTrack& obj = *dest;
19248 result7->ref = (long) (&obj);
19249 result7->obj.i = (long) (&obj);
19250 return(1 || funcname || hash || result7 || libp) ;
19251}
19252
19253
19254/* TMdcDedx */
19255static int G__RootEventData_rootcint_481_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19256{
19257 TMdcDedx* p = NULL;
19258 char* gvp = (char*) G__getgvp();
19259 int n = G__getaryconstruct();
19260 if (n) {
19261 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
19262 p = new TMdcDedx[n];
19263 } else {
19264 p = new((void*) gvp) TMdcDedx[n];
19265 }
19266 } else {
19267 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
19268 p = new TMdcDedx;
19269 } else {
19270 p = new((void*) gvp) TMdcDedx;
19271 }
19272 }
19273 result7->obj.i = (long) p;
19274 result7->ref = (long) p;
19275 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx));
19276 return(1 || funcname || hash || result7 || libp) ;
19277}
19278
19279static int G__RootEventData_rootcint_481_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19280{
19281 G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->trackId());
19282 return(1 || funcname || hash || result7 || libp) ;
19283}
19284
19285static int G__RootEventData_rootcint_481_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19286{
19287 G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->particleId());
19288 return(1 || funcname || hash || result7 || libp) ;
19289}
19290
19291static int G__RootEventData_rootcint_481_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19292{
19293 G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->status());
19294 return(1 || funcname || hash || result7 || libp) ;
19295}
19296
19297static int G__RootEventData_rootcint_481_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19298{
19299 G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->truncAlg());
19300 return(1 || funcname || hash || result7 || libp) ;
19301}
19302
19303static int G__RootEventData_rootcint_481_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19304{
19305 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chi((int) G__int(libp->para[0])));
19306 return(1 || funcname || hash || result7 || libp) ;
19307}
19308
19309static int G__RootEventData_rootcint_481_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19310{
19311 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiE());
19312 return(1 || funcname || hash || result7 || libp) ;
19313}
19314
19315static int G__RootEventData_rootcint_481_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19316{
19317 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiMu());
19318 return(1 || funcname || hash || result7 || libp) ;
19319}
19320
19321static int G__RootEventData_rootcint_481_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19322{
19323 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiPi());
19324 return(1 || funcname || hash || result7 || libp) ;
19325}
19326
19327static int G__RootEventData_rootcint_481_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19328{
19329 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiK());
19330 return(1 || funcname || hash || result7 || libp) ;
19331}
19332
19333static int G__RootEventData_rootcint_481_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19334{
19335 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiP());
19336 return(1 || funcname || hash || result7 || libp) ;
19337}
19338
19339static int G__RootEventData_rootcint_481_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19340{
19341 G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->numGoodHits());
19342 return(1 || funcname || hash || result7 || libp) ;
19343}
19344
19345static int G__RootEventData_rootcint_481_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19346{
19347 G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->numTotalHits());
19348 return(1 || funcname || hash || result7 || libp) ;
19349}
19350
19351static int G__RootEventData_rootcint_481_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19352{
19353 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->probPH());
19354 return(1 || funcname || hash || result7 || libp) ;
19355}
19356
19357static int G__RootEventData_rootcint_481_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19358{
19359 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->normPH());
19360 return(1 || funcname || hash || result7 || libp) ;
19361}
19362
19363static int G__RootEventData_rootcint_481_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19364{
19365 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->errorPH());
19366 return(1 || funcname || hash || result7 || libp) ;
19367}
19368
19369static int G__RootEventData_rootcint_481_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19370{
19371 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->twentyPH());
19372 return(1 || funcname || hash || result7 || libp) ;
19373}
19374
19375static int G__RootEventData_rootcint_481_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19376{
19377 ((TMdcDedx*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
19378 G__setnull(result7);
19379 return(1 || funcname || hash || result7 || libp) ;
19380}
19381
19382static int G__RootEventData_rootcint_481_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19383{
19384 ((TMdcDedx*) G__getstructoffset())->setParticleId((const Int_t) G__int(libp->para[0]));
19385 G__setnull(result7);
19386 return(1 || funcname || hash || result7 || libp) ;
19387}
19388
19389static int G__RootEventData_rootcint_481_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19390{
19391 ((TMdcDedx*) G__getstructoffset())->setStatus((const Int_t) G__int(libp->para[0]));
19392 G__setnull(result7);
19393 return(1 || funcname || hash || result7 || libp) ;
19394}
19395
19396static int G__RootEventData_rootcint_481_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19397{
19398 ((TMdcDedx*) G__getstructoffset())->setTruncAlg((const Int_t) G__int(libp->para[0]));
19399 G__setnull(result7);
19400 return(1 || funcname || hash || result7 || libp) ;
19401}
19402
19403static int G__RootEventData_rootcint_481_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19404{
19405 ((TMdcDedx*) G__getstructoffset())->setChiE((const Double_t) G__double(libp->para[0]));
19406 G__setnull(result7);
19407 return(1 || funcname || hash || result7 || libp) ;
19408}
19409
19410static int G__RootEventData_rootcint_481_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19411{
19412 ((TMdcDedx*) G__getstructoffset())->setChiMu((const Double_t) G__double(libp->para[0]));
19413 G__setnull(result7);
19414 return(1 || funcname || hash || result7 || libp) ;
19415}
19416
19417static int G__RootEventData_rootcint_481_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19418{
19419 ((TMdcDedx*) G__getstructoffset())->setChiPi((const Double_t) G__double(libp->para[0]));
19420 G__setnull(result7);
19421 return(1 || funcname || hash || result7 || libp) ;
19422}
19423
19424static int G__RootEventData_rootcint_481_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19425{
19426 ((TMdcDedx*) G__getstructoffset())->setChiK((const Double_t) G__double(libp->para[0]));
19427 G__setnull(result7);
19428 return(1 || funcname || hash || result7 || libp) ;
19429}
19430
19431static int G__RootEventData_rootcint_481_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19432{
19433 ((TMdcDedx*) G__getstructoffset())->setChiP((const Double_t) G__double(libp->para[0]));
19434 G__setnull(result7);
19435 return(1 || funcname || hash || result7 || libp) ;
19436}
19437
19438static int G__RootEventData_rootcint_481_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19439{
19440 ((TMdcDedx*) G__getstructoffset())->setNumGoodHits((const Int_t) G__int(libp->para[0]));
19441 G__setnull(result7);
19442 return(1 || funcname || hash || result7 || libp) ;
19443}
19444
19445static int G__RootEventData_rootcint_481_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19446{
19447 ((TMdcDedx*) G__getstructoffset())->setNumTotalHits((const Int_t) G__int(libp->para[0]));
19448 G__setnull(result7);
19449 return(1 || funcname || hash || result7 || libp) ;
19450}
19451
19452static int G__RootEventData_rootcint_481_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19453{
19454 ((TMdcDedx*) G__getstructoffset())->setProbPH((const Double_t) G__double(libp->para[0]));
19455 G__setnull(result7);
19456 return(1 || funcname || hash || result7 || libp) ;
19457}
19458
19459static int G__RootEventData_rootcint_481_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19460{
19461 ((TMdcDedx*) G__getstructoffset())->setNormPH((const Double_t) G__double(libp->para[0]));
19462 G__setnull(result7);
19463 return(1 || funcname || hash || result7 || libp) ;
19464}
19465
19466static int G__RootEventData_rootcint_481_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19467{
19468 ((TMdcDedx*) G__getstructoffset())->setErrorPH((const Double_t) G__double(libp->para[0]));
19469 G__setnull(result7);
19470 return(1 || funcname || hash || result7 || libp) ;
19471}
19472
19473static int G__RootEventData_rootcint_481_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19474{
19475 ((TMdcDedx*) G__getstructoffset())->setTwentyPH((const Double_t) G__double(libp->para[0]));
19476 G__setnull(result7);
19477 return(1 || funcname || hash || result7 || libp) ;
19478}
19479
19480static int G__RootEventData_rootcint_481_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19481{
19482 G__letint(result7, 85, (long) TMdcDedx::Class());
19483 return(1 || funcname || hash || result7 || libp) ;
19484}
19485
19486static int G__RootEventData_rootcint_481_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19487{
19488 G__letint(result7, 67, (long) TMdcDedx::Class_Name());
19489 return(1 || funcname || hash || result7 || libp) ;
19490}
19491
19492static int G__RootEventData_rootcint_481_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19493{
19494 G__letint(result7, 115, (long) TMdcDedx::Class_Version());
19495 return(1 || funcname || hash || result7 || libp) ;
19496}
19497
19498static int G__RootEventData_rootcint_481_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19499{
19500 TMdcDedx::Dictionary();
19501 G__setnull(result7);
19502 return(1 || funcname || hash || result7 || libp) ;
19503}
19504
19505static int G__RootEventData_rootcint_481_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19506{
19507 ((TMdcDedx*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
19508 G__setnull(result7);
19509 return(1 || funcname || hash || result7 || libp) ;
19510}
19511
19512static int G__RootEventData_rootcint_481_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19513{
19514 G__letint(result7, 67, (long) TMdcDedx::DeclFileName());
19515 return(1 || funcname || hash || result7 || libp) ;
19516}
19517
19518static int G__RootEventData_rootcint_481_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19519{
19520 G__letint(result7, 105, (long) TMdcDedx::ImplFileLine());
19521 return(1 || funcname || hash || result7 || libp) ;
19522}
19523
19524static int G__RootEventData_rootcint_481_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19525{
19526 G__letint(result7, 67, (long) TMdcDedx::ImplFileName());
19527 return(1 || funcname || hash || result7 || libp) ;
19528}
19529
19530static int G__RootEventData_rootcint_481_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19531{
19532 G__letint(result7, 105, (long) TMdcDedx::DeclFileLine());
19533 return(1 || funcname || hash || result7 || libp) ;
19534}
19535
19536// automatic copy constructor
19537static int G__RootEventData_rootcint_481_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19538
19539{
19540 TMdcDedx* p;
19541 void* tmp = (void*) G__int(libp->para[0]);
19542 p = new TMdcDedx(*(TMdcDedx*) tmp);
19543 result7->obj.i = (long) p;
19544 result7->ref = (long) p;
19545 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx));
19546 return(1 || funcname || hash || result7 || libp) ;
19547}
19548
19549// automatic destructor
19550typedef TMdcDedx G__TTMdcDedx;
19551static int G__RootEventData_rootcint_481_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19552{
19553 char* gvp = (char*) G__getgvp();
19554 long soff = G__getstructoffset();
19555 int n = G__getaryconstruct();
19556 //
19557 //has_a_delete: 1
19558 //has_own_delete1arg: 0
19559 //has_own_delete2arg: 0
19560 //
19561 if (!soff) {
19562 return(1);
19563 }
19564 if (n) {
19565 if (gvp == (char*)G__PVOID) {
19566 delete[] (TMdcDedx*) soff;
19567 } else {
19568 G__setgvp((long) G__PVOID);
19569 for (int i = n - 1; i >= 0; --i) {
19570 ((TMdcDedx*) (soff+(sizeof(TMdcDedx)*i)))->~G__TTMdcDedx();
19571 }
19572 G__setgvp((long)gvp);
19573 }
19574 } else {
19575 if (gvp == (char*)G__PVOID) {
19576 delete (TMdcDedx*) soff;
19577 } else {
19578 G__setgvp((long) G__PVOID);
19579 ((TMdcDedx*) (soff))->~G__TTMdcDedx();
19580 G__setgvp((long)gvp);
19581 }
19582 }
19583 G__setnull(result7);
19584 return(1 || funcname || hash || result7 || libp) ;
19585}
19586
19587// automatic assignment operator
19588static int G__RootEventData_rootcint_481_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19589{
19590 TMdcDedx* dest = (TMdcDedx*) G__getstructoffset();
19591 *dest = *(TMdcDedx*) libp->para[0].ref;
19592 const TMdcDedx& obj = *dest;
19593 result7->ref = (long) (&obj);
19594 result7->obj.i = (long) (&obj);
19595 return(1 || funcname || hash || result7 || libp) ;
19596}
19597
19598
19599/* TExtTrack */
19600static int G__RootEventData_rootcint_483_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19601{
19602 TExtTrack* p = NULL;
19603 char* gvp = (char*) G__getgvp();
19604 int n = G__getaryconstruct();
19605 if (n) {
19606 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
19607 p = new TExtTrack[n];
19608 } else {
19609 p = new((void*) gvp) TExtTrack[n];
19610 }
19611 } else {
19612 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
19613 p = new TExtTrack;
19614 } else {
19615 p = new((void*) gvp) TExtTrack;
19616 }
19617 }
19618 result7->obj.i = (long) p;
19619 result7->ref = (long) p;
19620 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack));
19621 return(1 || funcname || hash || result7 || libp) ;
19622}
19623
19624static int G__RootEventData_rootcint_483_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19625{
19626 ((TExtTrack*) G__getstructoffset())->SetTrackId((const Int_t) G__int(libp->para[0]));
19627 G__setnull(result7);
19628 return(1 || funcname || hash || result7 || libp) ;
19629}
19630
19631static int G__RootEventData_rootcint_483_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19632{
19633 ((TExtTrack*) G__getstructoffset())->SetTof1PositionX((const Double_t) G__double(libp->para[0]));
19634 G__setnull(result7);
19635 return(1 || funcname || hash || result7 || libp) ;
19636}
19637
19638static int G__RootEventData_rootcint_483_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19639{
19640 ((TExtTrack*) G__getstructoffset())->SetTof1PositionY((const Double_t) G__double(libp->para[0]));
19641 G__setnull(result7);
19642 return(1 || funcname || hash || result7 || libp) ;
19643}
19644
19645static int G__RootEventData_rootcint_483_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19646{
19647 ((TExtTrack*) G__getstructoffset())->SetTof1PositionZ((const Double_t) G__double(libp->para[0]));
19648 G__setnull(result7);
19649 return(1 || funcname || hash || result7 || libp) ;
19650}
19651
19652static int G__RootEventData_rootcint_483_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19653{
19654 ((TExtTrack*) G__getstructoffset())->SetTof1MomentumX((const Double_t) G__double(libp->para[0]));
19655 G__setnull(result7);
19656 return(1 || funcname || hash || result7 || libp) ;
19657}
19658
19659static int G__RootEventData_rootcint_483_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19660{
19661 ((TExtTrack*) G__getstructoffset())->SetTof1MomentumY((const Double_t) G__double(libp->para[0]));
19662 G__setnull(result7);
19663 return(1 || funcname || hash || result7 || libp) ;
19664}
19665
19666static int G__RootEventData_rootcint_483_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19667{
19668 ((TExtTrack*) G__getstructoffset())->SetTof1MomentumZ((const Double_t) G__double(libp->para[0]));
19669 G__setnull(result7);
19670 return(1 || funcname || hash || result7 || libp) ;
19671}
19672
19673static int G__RootEventData_rootcint_483_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19674{
19675 ((TExtTrack*) G__getstructoffset())->SetTof1VolumeName(*((const TString*) G__int(libp->para[0])));
19676 G__setnull(result7);
19677 return(1 || funcname || hash || result7 || libp) ;
19678}
19679
19680static int G__RootEventData_rootcint_483_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19681{
19682 ((TExtTrack*) G__getstructoffset())->SetTof1VolumeNumber((const Int_t) G__int(libp->para[0]));
19683 G__setnull(result7);
19684 return(1 || funcname || hash || result7 || libp) ;
19685}
19686
19687static int G__RootEventData_rootcint_483_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19688{
19689 ((TExtTrack*) G__getstructoffset())->SetTof1((const Double_t) G__double(libp->para[0]));
19690 G__setnull(result7);
19691 return(1 || funcname || hash || result7 || libp) ;
19692}
19693
19694static int G__RootEventData_rootcint_483_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19695{
19696 ((TExtTrack*) G__getstructoffset())->SetTof1Path((const Double_t) G__double(libp->para[0]));
19697 G__setnull(result7);
19698 return(1 || funcname || hash || result7 || libp) ;
19699}
19700
19701static int G__RootEventData_rootcint_483_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19702{
19703 ((TExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
19704 G__setnull(result7);
19705 return(1 || funcname || hash || result7 || libp) ;
19706}
19707
19708static int G__RootEventData_rootcint_483_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19709{
19710 ((TExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongT((const Double_t) G__double(libp->para[0]));
19711 G__setnull(result7);
19712 return(1 || funcname || hash || result7 || libp) ;
19713}
19714
19715static int G__RootEventData_rootcint_483_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19716{
19717 ((TExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongX((const Double_t) G__double(libp->para[0]));
19718 G__setnull(result7);
19719 return(1 || funcname || hash || result7 || libp) ;
19720}
19721
19722static int G__RootEventData_rootcint_483_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19723{
19724 ((TExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongY((const Double_t) G__double(libp->para[0]));
19725 G__setnull(result7);
19726 return(1 || funcname || hash || result7 || libp) ;
19727}
19728
19729static int G__RootEventData_rootcint_483_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19730{
19731 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
19732 ((TExtTrack*) G__getstructoffset())->SetTof1ErrorMatrix(G__Ap0->a);
19733 G__setnull(result7);
19734 return(1 || funcname || hash || result7 || libp) ;
19735}
19736
19737static int G__RootEventData_rootcint_483_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19738{
19739 ((TExtTrack*) G__getstructoffset())->SetTof2PositionX((const Double_t) G__double(libp->para[0]));
19740 G__setnull(result7);
19741 return(1 || funcname || hash || result7 || libp) ;
19742}
19743
19744static int G__RootEventData_rootcint_483_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19745{
19746 ((TExtTrack*) G__getstructoffset())->SetTof2PositionY((const Double_t) G__double(libp->para[0]));
19747 G__setnull(result7);
19748 return(1 || funcname || hash || result7 || libp) ;
19749}
19750
19751static int G__RootEventData_rootcint_483_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19752{
19753 ((TExtTrack*) G__getstructoffset())->SetTof2PositionZ((const Double_t) G__double(libp->para[0]));
19754 G__setnull(result7);
19755 return(1 || funcname || hash || result7 || libp) ;
19756}
19757
19758static int G__RootEventData_rootcint_483_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19759{
19760 ((TExtTrack*) G__getstructoffset())->SetTof2MomentumX((const Double_t) G__double(libp->para[0]));
19761 G__setnull(result7);
19762 return(1 || funcname || hash || result7 || libp) ;
19763}
19764
19765static int G__RootEventData_rootcint_483_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19766{
19767 ((TExtTrack*) G__getstructoffset())->SetTof2MomentumY((const Double_t) G__double(libp->para[0]));
19768 G__setnull(result7);
19769 return(1 || funcname || hash || result7 || libp) ;
19770}
19771
19772static int G__RootEventData_rootcint_483_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19773{
19774 ((TExtTrack*) G__getstructoffset())->SetTof2MomentumZ((const Double_t) G__double(libp->para[0]));
19775 G__setnull(result7);
19776 return(1 || funcname || hash || result7 || libp) ;
19777}
19778
19779static int G__RootEventData_rootcint_483_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19780{
19781 ((TExtTrack*) G__getstructoffset())->SetTof2VolumeName(*((const TString*) G__int(libp->para[0])));
19782 G__setnull(result7);
19783 return(1 || funcname || hash || result7 || libp) ;
19784}
19785
19786static int G__RootEventData_rootcint_483_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19787{
19788 ((TExtTrack*) G__getstructoffset())->SetTof2VolumeNumber((const Int_t) G__int(libp->para[0]));
19789 G__setnull(result7);
19790 return(1 || funcname || hash || result7 || libp) ;
19791}
19792
19793static int G__RootEventData_rootcint_483_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19794{
19795 ((TExtTrack*) G__getstructoffset())->SetTof2((const Double_t) G__double(libp->para[0]));
19796 G__setnull(result7);
19797 return(1 || funcname || hash || result7 || libp) ;
19798}
19799
19800static int G__RootEventData_rootcint_483_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19801{
19802 ((TExtTrack*) G__getstructoffset())->SetTof2Path((const Double_t) G__double(libp->para[0]));
19803 G__setnull(result7);
19804 return(1 || funcname || hash || result7 || libp) ;
19805}
19806
19807static int G__RootEventData_rootcint_483_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19808{
19809 ((TExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
19810 G__setnull(result7);
19811 return(1 || funcname || hash || result7 || libp) ;
19812}
19813
19814static int G__RootEventData_rootcint_483_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19815{
19816 ((TExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongT((const Double_t) G__double(libp->para[0]));
19817 G__setnull(result7);
19818 return(1 || funcname || hash || result7 || libp) ;
19819}
19820
19821static int G__RootEventData_rootcint_483_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19822{
19823 ((TExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongX((const Double_t) G__double(libp->para[0]));
19824 G__setnull(result7);
19825 return(1 || funcname || hash || result7 || libp) ;
19826}
19827
19828static int G__RootEventData_rootcint_483_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19829{
19830 ((TExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongY((const Double_t) G__double(libp->para[0]));
19831 G__setnull(result7);
19832 return(1 || funcname || hash || result7 || libp) ;
19833}
19834
19835static int G__RootEventData_rootcint_483_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19836{
19837 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
19838 ((TExtTrack*) G__getstructoffset())->SetTof2ErrorMatrix(G__Ap0->a);
19839 G__setnull(result7);
19840 return(1 || funcname || hash || result7 || libp) ;
19841}
19842
19843static int G__RootEventData_rootcint_483_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19844{
19845 ((TExtTrack*) G__getstructoffset())->SetEmcPositionX((const Double_t) G__double(libp->para[0]));
19846 G__setnull(result7);
19847 return(1 || funcname || hash || result7 || libp) ;
19848}
19849
19850static int G__RootEventData_rootcint_483_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19851{
19852 ((TExtTrack*) G__getstructoffset())->SetEmcPositionY((const Double_t) G__double(libp->para[0]));
19853 G__setnull(result7);
19854 return(1 || funcname || hash || result7 || libp) ;
19855}
19856
19857static int G__RootEventData_rootcint_483_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19858{
19859 ((TExtTrack*) G__getstructoffset())->SetEmcPositionZ((const Double_t) G__double(libp->para[0]));
19860 G__setnull(result7);
19861 return(1 || funcname || hash || result7 || libp) ;
19862}
19863
19864static int G__RootEventData_rootcint_483_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19865{
19866 ((TExtTrack*) G__getstructoffset())->SetEmcMomentumX((const Double_t) G__double(libp->para[0]));
19867 G__setnull(result7);
19868 return(1 || funcname || hash || result7 || libp) ;
19869}
19870
19871static int G__RootEventData_rootcint_483_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19872{
19873 ((TExtTrack*) G__getstructoffset())->SetEmcMomentumY((const Double_t) G__double(libp->para[0]));
19874 G__setnull(result7);
19875 return(1 || funcname || hash || result7 || libp) ;
19876}
19877
19878static int G__RootEventData_rootcint_483_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19879{
19880 ((TExtTrack*) G__getstructoffset())->SetEmcMomentumZ((const Double_t) G__double(libp->para[0]));
19881 G__setnull(result7);
19882 return(1 || funcname || hash || result7 || libp) ;
19883}
19884
19885static int G__RootEventData_rootcint_483_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19886{
19887 ((TExtTrack*) G__getstructoffset())->SetEmcVolumeName(*((const TString*) G__int(libp->para[0])));
19888 G__setnull(result7);
19889 return(1 || funcname || hash || result7 || libp) ;
19890}
19891
19892static int G__RootEventData_rootcint_483_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19893{
19894 ((TExtTrack*) G__getstructoffset())->SetEmcVolumeNumber((const Int_t) G__int(libp->para[0]));
19895 G__setnull(result7);
19896 return(1 || funcname || hash || result7 || libp) ;
19897}
19898
19899static int G__RootEventData_rootcint_483_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19900{
19901 ((TExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongTheta((const Double_t) G__double(libp->para[0]));
19902 G__setnull(result7);
19903 return(1 || funcname || hash || result7 || libp) ;
19904}
19905
19906static int G__RootEventData_rootcint_483_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19907{
19908 ((TExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongPhi((const Double_t) G__double(libp->para[0]));
19909 G__setnull(result7);
19910 return(1 || funcname || hash || result7 || libp) ;
19911}
19912
19913static int G__RootEventData_rootcint_483_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19914{
19915 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
19916 ((TExtTrack*) G__getstructoffset())->SetEmcErrorMatrix(G__Ap0->a);
19917 G__setnull(result7);
19918 return(1 || funcname || hash || result7 || libp) ;
19919}
19920
19921static int G__RootEventData_rootcint_483_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19922{
19923 ((TExtTrack*) G__getstructoffset())->SetEmcPath((Double_t) G__double(libp->para[0]));
19924 G__setnull(result7);
19925 return(1 || funcname || hash || result7 || libp) ;
19926}
19927
19928static int G__RootEventData_rootcint_483_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19929{
19930 ((TExtTrack*) G__getstructoffset())->SetMucPositionX((const Double_t) G__double(libp->para[0]));
19931 G__setnull(result7);
19932 return(1 || funcname || hash || result7 || libp) ;
19933}
19934
19935static int G__RootEventData_rootcint_483_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19936{
19937 ((TExtTrack*) G__getstructoffset())->SetMucPositionY((const Double_t) G__double(libp->para[0]));
19938 G__setnull(result7);
19939 return(1 || funcname || hash || result7 || libp) ;
19940}
19941
19942static int G__RootEventData_rootcint_483_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19943{
19944 ((TExtTrack*) G__getstructoffset())->SetMucPositionZ((const Double_t) G__double(libp->para[0]));
19945 G__setnull(result7);
19946 return(1 || funcname || hash || result7 || libp) ;
19947}
19948
19949static int G__RootEventData_rootcint_483_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19950{
19951 ((TExtTrack*) G__getstructoffset())->SetMucMomentumX((const Double_t) G__double(libp->para[0]));
19952 G__setnull(result7);
19953 return(1 || funcname || hash || result7 || libp) ;
19954}
19955
19956static int G__RootEventData_rootcint_483_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19957{
19958 ((TExtTrack*) G__getstructoffset())->SetMucMomentumY((const Double_t) G__double(libp->para[0]));
19959 G__setnull(result7);
19960 return(1 || funcname || hash || result7 || libp) ;
19961}
19962
19963static int G__RootEventData_rootcint_483_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19964{
19965 ((TExtTrack*) G__getstructoffset())->SetMucMomentumZ((const Double_t) G__double(libp->para[0]));
19966 G__setnull(result7);
19967 return(1 || funcname || hash || result7 || libp) ;
19968}
19969
19970static int G__RootEventData_rootcint_483_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19971{
19972 ((TExtTrack*) G__getstructoffset())->SetMucVolumeName(*((const TString*) G__int(libp->para[0])));
19973 G__setnull(result7);
19974 return(1 || funcname || hash || result7 || libp) ;
19975}
19976
19977static int G__RootEventData_rootcint_483_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19978{
19979 ((TExtTrack*) G__getstructoffset())->SetMucVolumeNumber((const Int_t) G__int(libp->para[0]));
19980 G__setnull(result7);
19981 return(1 || funcname || hash || result7 || libp) ;
19982}
19983
19984static int G__RootEventData_rootcint_483_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19985{
19986 ((TExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
19987 G__setnull(result7);
19988 return(1 || funcname || hash || result7 || libp) ;
19989}
19990
19991static int G__RootEventData_rootcint_483_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19992{
19993 ((TExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongT((const Double_t) G__double(libp->para[0]));
19994 G__setnull(result7);
19995 return(1 || funcname || hash || result7 || libp) ;
19996}
19997
19998static int G__RootEventData_rootcint_483_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19999{
20000 ((TExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongX((const Double_t) G__double(libp->para[0]));
20001 G__setnull(result7);
20002 return(1 || funcname || hash || result7 || libp) ;
20003}
20004
20005static int G__RootEventData_rootcint_483_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20006{
20007 ((TExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongY((const Double_t) G__double(libp->para[0]));
20008 G__setnull(result7);
20009 return(1 || funcname || hash || result7 || libp) ;
20010}
20011
20012static int G__RootEventData_rootcint_483_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20013{
20014 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20015 ((TExtTrack*) G__getstructoffset())->SetMucErrorMatrix(G__Ap0->a);
20016 G__setnull(result7);
20017 return(1 || funcname || hash || result7 || libp) ;
20018}
20019
20020static int G__RootEventData_rootcint_483_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20021{
20022 G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetTrackId());
20023 return(1 || funcname || hash || result7 || libp) ;
20024}
20025
20026static int G__RootEventData_rootcint_483_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20027{
20028 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PositionX());
20029 return(1 || funcname || hash || result7 || libp) ;
20030}
20031
20032static int G__RootEventData_rootcint_483_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20033{
20034 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PositionY());
20035 return(1 || funcname || hash || result7 || libp) ;
20036}
20037
20038static int G__RootEventData_rootcint_483_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20039{
20040 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PositionZ());
20041 return(1 || funcname || hash || result7 || libp) ;
20042}
20043
20044static int G__RootEventData_rootcint_483_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20045{
20046 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1MomentumX());
20047 return(1 || funcname || hash || result7 || libp) ;
20048}
20049
20050static int G__RootEventData_rootcint_483_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20051{
20052 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1MomentumY());
20053 return(1 || funcname || hash || result7 || libp) ;
20054}
20055
20056static int G__RootEventData_rootcint_483_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20057{
20058 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1MomentumZ());
20059 return(1 || funcname || hash || result7 || libp) ;
20060}
20061
20062static int G__RootEventData_rootcint_483_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20063{
20064 {
20065 const TString* pobj;
20066 const TString xobj = ((const TExtTrack*) G__getstructoffset())->GetTof1VolumeName();
20067 pobj = new TString(xobj);
20068 result7->obj.i = (long) ((void*) pobj);
20069 result7->ref = result7->obj.i;
20070 G__store_tempobject(*result7);
20071 }
20072 return(1 || funcname || hash || result7 || libp) ;
20073}
20074
20075static int G__RootEventData_rootcint_483_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20076{
20077 G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetTof1VolumeNumber());
20078 return(1 || funcname || hash || result7 || libp) ;
20079}
20080
20081static int G__RootEventData_rootcint_483_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20082{
20083 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1());
20084 return(1 || funcname || hash || result7 || libp) ;
20085}
20086
20087static int G__RootEventData_rootcint_483_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20088{
20089 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1Path());
20090 return(1 || funcname || hash || result7 || libp) ;
20091}
20092
20093static int G__RootEventData_rootcint_483_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20094{
20095 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongZ());
20096 return(1 || funcname || hash || result7 || libp) ;
20097}
20098
20099static int G__RootEventData_rootcint_483_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20100{
20101 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongT());
20102 return(1 || funcname || hash || result7 || libp) ;
20103}
20104
20105static int G__RootEventData_rootcint_483_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20106{
20107 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongX());
20108 return(1 || funcname || hash || result7 || libp) ;
20109}
20110
20111static int G__RootEventData_rootcint_483_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20112{
20113 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongY());
20114 return(1 || funcname || hash || result7 || libp) ;
20115}
20116
20117static int G__RootEventData_rootcint_483_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20118{
20119 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20120 return(1 || funcname || hash || result7 || libp) ;
20121}
20122
20123static int G__RootEventData_rootcint_483_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20124{
20125 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PositionX());
20126 return(1 || funcname || hash || result7 || libp) ;
20127}
20128
20129static int G__RootEventData_rootcint_483_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20130{
20131 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PositionY());
20132 return(1 || funcname || hash || result7 || libp) ;
20133}
20134
20135static int G__RootEventData_rootcint_483_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20136{
20137 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PositionZ());
20138 return(1 || funcname || hash || result7 || libp) ;
20139}
20140
20141static int G__RootEventData_rootcint_483_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20142{
20143 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2MomentumX());
20144 return(1 || funcname || hash || result7 || libp) ;
20145}
20146
20147static int G__RootEventData_rootcint_483_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20148{
20149 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2MomentumY());
20150 return(1 || funcname || hash || result7 || libp) ;
20151}
20152
20153static int G__RootEventData_rootcint_483_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20154{
20155 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2MomentumZ());
20156 return(1 || funcname || hash || result7 || libp) ;
20157}
20158
20159static int G__RootEventData_rootcint_483_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20160{
20161 {
20162 const TString* pobj;
20163 const TString xobj = ((const TExtTrack*) G__getstructoffset())->GetTof2VolumeName();
20164 pobj = new TString(xobj);
20165 result7->obj.i = (long) ((void*) pobj);
20166 result7->ref = result7->obj.i;
20167 G__store_tempobject(*result7);
20168 }
20169 return(1 || funcname || hash || result7 || libp) ;
20170}
20171
20172static int G__RootEventData_rootcint_483_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20173{
20174 G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetTof2VolumeNumber());
20175 return(1 || funcname || hash || result7 || libp) ;
20176}
20177
20178static int G__RootEventData_rootcint_483_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20179{
20180 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2());
20181 return(1 || funcname || hash || result7 || libp) ;
20182}
20183
20184static int G__RootEventData_rootcint_483_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20185{
20186 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2Path());
20187 return(1 || funcname || hash || result7 || libp) ;
20188}
20189
20190static int G__RootEventData_rootcint_483_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20191{
20192 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongZ());
20193 return(1 || funcname || hash || result7 || libp) ;
20194}
20195
20196static int G__RootEventData_rootcint_483_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20197{
20198 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongT());
20199 return(1 || funcname || hash || result7 || libp) ;
20200}
20201
20202static int G__RootEventData_rootcint_483_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20203{
20204 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongX());
20205 return(1 || funcname || hash || result7 || libp) ;
20206}
20207
20208static int G__RootEventData_rootcint_483_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20209{
20210 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongY());
20211 return(1 || funcname || hash || result7 || libp) ;
20212}
20213
20214static int G__RootEventData_rootcint_483_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20215{
20216 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20217 return(1 || funcname || hash || result7 || libp) ;
20218}
20219
20220static int G__RootEventData_rootcint_483_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20221{
20222 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPositionX());
20223 return(1 || funcname || hash || result7 || libp) ;
20224}
20225
20226static int G__RootEventData_rootcint_483_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20227{
20228 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPositionY());
20229 return(1 || funcname || hash || result7 || libp) ;
20230}
20231
20232static int G__RootEventData_rootcint_483_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20233{
20234 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPositionZ());
20235 return(1 || funcname || hash || result7 || libp) ;
20236}
20237
20238static int G__RootEventData_rootcint_483_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20239{
20240 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcMomentumX());
20241 return(1 || funcname || hash || result7 || libp) ;
20242}
20243
20244static int G__RootEventData_rootcint_483_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20245{
20246 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcMomentumY());
20247 return(1 || funcname || hash || result7 || libp) ;
20248}
20249
20250static int G__RootEventData_rootcint_483_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20251{
20252 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcMomentumZ());
20253 return(1 || funcname || hash || result7 || libp) ;
20254}
20255
20256static int G__RootEventData_rootcint_483_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20257{
20258 {
20259 const TString* pobj;
20260 const TString xobj = ((const TExtTrack*) G__getstructoffset())->GetEmcVolumeName();
20261 pobj = new TString(xobj);
20262 result7->obj.i = (long) ((void*) pobj);
20263 result7->ref = result7->obj.i;
20264 G__store_tempobject(*result7);
20265 }
20266 return(1 || funcname || hash || result7 || libp) ;
20267}
20268
20269static int G__RootEventData_rootcint_483_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20270{
20271 G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetEmcVolumeNumber());
20272 return(1 || funcname || hash || result7 || libp) ;
20273}
20274
20275static int G__RootEventData_rootcint_483_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20276{
20277 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongTheta());
20278 return(1 || funcname || hash || result7 || libp) ;
20279}
20280
20281static int G__RootEventData_rootcint_483_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20282{
20283 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongPhi());
20284 return(1 || funcname || hash || result7 || libp) ;
20285}
20286
20287static int G__RootEventData_rootcint_483_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20288{
20289 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20290 return(1 || funcname || hash || result7 || libp) ;
20291}
20292
20293static int G__RootEventData_rootcint_483_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20294{
20295 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->emcPath());
20296 return(1 || funcname || hash || result7 || libp) ;
20297}
20298
20299static int G__RootEventData_rootcint_483_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20300{
20301 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPositionX());
20302 return(1 || funcname || hash || result7 || libp) ;
20303}
20304
20305static int G__RootEventData_rootcint_483_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20306{
20307 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPositionY());
20308 return(1 || funcname || hash || result7 || libp) ;
20309}
20310
20311static int G__RootEventData_rootcint_483_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20312{
20313 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPositionZ());
20314 return(1 || funcname || hash || result7 || libp) ;
20315}
20316
20317static int G__RootEventData_rootcint_483_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20318{
20319 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucMomentumX());
20320 return(1 || funcname || hash || result7 || libp) ;
20321}
20322
20323static int G__RootEventData_rootcint_483_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20324{
20325 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucMomentumY());
20326 return(1 || funcname || hash || result7 || libp) ;
20327}
20328
20329static int G__RootEventData_rootcint_483_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20330{
20331 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucMomentumZ());
20332 return(1 || funcname || hash || result7 || libp) ;
20333}
20334
20335static int G__RootEventData_rootcint_483_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20336{
20337 {
20338 const TString* pobj;
20339 const TString xobj = ((const TExtTrack*) G__getstructoffset())->GetMucVolumeName();
20340 pobj = new TString(xobj);
20341 result7->obj.i = (long) ((void*) pobj);
20342 result7->ref = result7->obj.i;
20343 G__store_tempobject(*result7);
20344 }
20345 return(1 || funcname || hash || result7 || libp) ;
20346}
20347
20348static int G__RootEventData_rootcint_483_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20349{
20350 G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetMucVolumeNumber());
20351 return(1 || funcname || hash || result7 || libp) ;
20352}
20353
20354static int G__RootEventData_rootcint_483_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20355{
20356 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongZ());
20357 return(1 || funcname || hash || result7 || libp) ;
20358}
20359
20360static int G__RootEventData_rootcint_483_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20361{
20362 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongT());
20363 return(1 || funcname || hash || result7 || libp) ;
20364}
20365
20366static int G__RootEventData_rootcint_483_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20367{
20368 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongX());
20369 return(1 || funcname || hash || result7 || libp) ;
20370}
20371
20372static int G__RootEventData_rootcint_483_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20373{
20374 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongY());
20375 return(1 || funcname || hash || result7 || libp) ;
20376}
20377
20378static int G__RootEventData_rootcint_483_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20379{
20380 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20381 return(1 || funcname || hash || result7 || libp) ;
20382}
20383
20384static int G__RootEventData_rootcint_483_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20385{
20386 G__letint(result7, 85, (long) TExtTrack::Class());
20387 return(1 || funcname || hash || result7 || libp) ;
20388}
20389
20390static int G__RootEventData_rootcint_483_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20391{
20392 G__letint(result7, 67, (long) TExtTrack::Class_Name());
20393 return(1 || funcname || hash || result7 || libp) ;
20394}
20395
20396static int G__RootEventData_rootcint_483_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20397{
20398 G__letint(result7, 115, (long) TExtTrack::Class_Version());
20399 return(1 || funcname || hash || result7 || libp) ;
20400}
20401
20402static int G__RootEventData_rootcint_483_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20403{
20404 TExtTrack::Dictionary();
20405 G__setnull(result7);
20406 return(1 || funcname || hash || result7 || libp) ;
20407}
20408
20409static int G__RootEventData_rootcint_483_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20410{
20411 ((TExtTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
20412 G__setnull(result7);
20413 return(1 || funcname || hash || result7 || libp) ;
20414}
20415
20416static int G__RootEventData_rootcint_483_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20417{
20418 G__letint(result7, 67, (long) TExtTrack::DeclFileName());
20419 return(1 || funcname || hash || result7 || libp) ;
20420}
20421
20422static int G__RootEventData_rootcint_483_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20423{
20424 G__letint(result7, 105, (long) TExtTrack::ImplFileLine());
20425 return(1 || funcname || hash || result7 || libp) ;
20426}
20427
20428static int G__RootEventData_rootcint_483_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20429{
20430 G__letint(result7, 67, (long) TExtTrack::ImplFileName());
20431 return(1 || funcname || hash || result7 || libp) ;
20432}
20433
20434static int G__RootEventData_rootcint_483_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20435{
20436 G__letint(result7, 105, (long) TExtTrack::DeclFileLine());
20437 return(1 || funcname || hash || result7 || libp) ;
20438}
20439
20440// automatic copy constructor
20441static int G__RootEventData_rootcint_483_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20442
20443{
20444 TExtTrack* p;
20445 void* tmp = (void*) G__int(libp->para[0]);
20446 p = new TExtTrack(*(TExtTrack*) tmp);
20447 result7->obj.i = (long) p;
20448 result7->ref = (long) p;
20449 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack));
20450 return(1 || funcname || hash || result7 || libp) ;
20451}
20452
20453// automatic destructor
20454typedef TExtTrack G__TTExtTrack;
20455static int G__RootEventData_rootcint_483_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20456{
20457 char* gvp = (char*) G__getgvp();
20458 long soff = G__getstructoffset();
20459 int n = G__getaryconstruct();
20460 //
20461 //has_a_delete: 1
20462 //has_own_delete1arg: 0
20463 //has_own_delete2arg: 0
20464 //
20465 if (!soff) {
20466 return(1);
20467 }
20468 if (n) {
20469 if (gvp == (char*)G__PVOID) {
20470 delete[] (TExtTrack*) soff;
20471 } else {
20472 G__setgvp((long) G__PVOID);
20473 for (int i = n - 1; i >= 0; --i) {
20474 ((TExtTrack*) (soff+(sizeof(TExtTrack)*i)))->~G__TTExtTrack();
20475 }
20476 G__setgvp((long)gvp);
20477 }
20478 } else {
20479 if (gvp == (char*)G__PVOID) {
20480 delete (TExtTrack*) soff;
20481 } else {
20482 G__setgvp((long) G__PVOID);
20483 ((TExtTrack*) (soff))->~G__TTExtTrack();
20484 G__setgvp((long)gvp);
20485 }
20486 }
20487 G__setnull(result7);
20488 return(1 || funcname || hash || result7 || libp) ;
20489}
20490
20491// automatic assignment operator
20492static int G__RootEventData_rootcint_483_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20493{
20494 TExtTrack* dest = (TExtTrack*) G__getstructoffset();
20495 *dest = *(TExtTrack*) libp->para[0].ref;
20496 const TExtTrack& obj = *dest;
20497 result7->ref = (long) (&obj);
20498 result7->obj.i = (long) (&obj);
20499 return(1 || funcname || hash || result7 || libp) ;
20500}
20501
20502
20503/* TMdcKalTrack */
20504static int G__RootEventData_rootcint_484_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20505{
20506 TMdcKalTrack* p = NULL;
20507 char* gvp = (char*) G__getgvp();
20508 int n = G__getaryconstruct();
20509 if (n) {
20510 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
20511 p = new TMdcKalTrack[n];
20512 } else {
20513 p = new((void*) gvp) TMdcKalTrack[n];
20514 }
20515 } else {
20516 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
20517 p = new TMdcKalTrack;
20518 } else {
20519 p = new((void*) gvp) TMdcKalTrack;
20520 }
20521 }
20522 result7->obj.i = (long) p;
20523 result7->ref = (long) p;
20524 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack));
20525 return(1 || funcname || hash || result7 || libp) ;
20526}
20527
20528static int G__RootEventData_rootcint_484_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20529{
20530 G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getTrackId());
20531 return(1 || funcname || hash || result7 || libp) ;
20532}
20533
20534static int G__RootEventData_rootcint_484_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20535{
20536 G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getStat((const Int_t) G__int(libp->para[0])));
20537 return(1 || funcname || hash || result7 || libp) ;
20538}
20539
20540static int G__RootEventData_rootcint_484_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20541{
20542 G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getStat2((const Int_t) G__int(libp->para[0])));
20543 return(1 || funcname || hash || result7 || libp) ;
20544}
20545
20546static int G__RootEventData_rootcint_484_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20547{
20548 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getChisq((const Int_t) G__int(libp->para[0])));
20549 return(1 || funcname || hash || result7 || libp) ;
20550}
20551
20552static int G__RootEventData_rootcint_484_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20553{
20554 G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getNdf((const Int_t) G__int(libp->para[0])));
20555 return(1 || funcname || hash || result7 || libp) ;
20556}
20557
20558static int G__RootEventData_rootcint_484_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20559{
20560 G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getNlayer((const Int_t) G__int(libp->para[0])));
20561 return(1 || funcname || hash || result7 || libp) ;
20562}
20563
20564static int G__RootEventData_rootcint_484_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20565{
20566 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelix((Int_t) G__int(libp->para[0])));
20567 return(1 || funcname || hash || result7 || libp) ;
20568}
20569
20570static int G__RootEventData_rootcint_484_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20571{
20572 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20573 return(1 || funcname || hash || result7 || libp) ;
20574}
20575
20576static int G__RootEventData_rootcint_484_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20577{
20578 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelixE((Int_t) G__int(libp->para[0])));
20579 return(1 || funcname || hash || result7 || libp) ;
20580}
20581
20582static int G__RootEventData_rootcint_484_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20583{
20584 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20585 return(1 || funcname || hash || result7 || libp) ;
20586}
20587
20588static int G__RootEventData_rootcint_484_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20589{
20590 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelixMu((Int_t) G__int(libp->para[0])));
20591 return(1 || funcname || hash || result7 || libp) ;
20592}
20593
20594static int G__RootEventData_rootcint_484_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20595{
20596 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20597 return(1 || funcname || hash || result7 || libp) ;
20598}
20599
20600static int G__RootEventData_rootcint_484_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20601{
20602 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelixK((Int_t) G__int(libp->para[0])));
20603 return(1 || funcname || hash || result7 || libp) ;
20604}
20605
20606static int G__RootEventData_rootcint_484_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20607{
20608 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20609 return(1 || funcname || hash || result7 || libp) ;
20610}
20611
20612static int G__RootEventData_rootcint_484_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20613{
20614 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelixP((Int_t) G__int(libp->para[0])));
20615 return(1 || funcname || hash || result7 || libp) ;
20616}
20617
20618static int G__RootEventData_rootcint_484_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20619{
20620 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20621 return(1 || funcname || hash || result7 || libp) ;
20622}
20623
20624static int G__RootEventData_rootcint_484_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20625{
20626 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelix((Int_t) G__int(libp->para[0])));
20627 return(1 || funcname || hash || result7 || libp) ;
20628}
20629
20630static int G__RootEventData_rootcint_484_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20631{
20632 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20633 return(1 || funcname || hash || result7 || libp) ;
20634}
20635
20636static int G__RootEventData_rootcint_484_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20637{
20638 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelixE((Int_t) G__int(libp->para[0])));
20639 return(1 || funcname || hash || result7 || libp) ;
20640}
20641
20642static int G__RootEventData_rootcint_484_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20643{
20644 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20645 return(1 || funcname || hash || result7 || libp) ;
20646}
20647
20648static int G__RootEventData_rootcint_484_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20649{
20650 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelixMu((Int_t) G__int(libp->para[0])));
20651 return(1 || funcname || hash || result7 || libp) ;
20652}
20653
20654static int G__RootEventData_rootcint_484_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20655{
20656 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20657 return(1 || funcname || hash || result7 || libp) ;
20658}
20659
20660static int G__RootEventData_rootcint_484_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20661{
20662 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelixK((Int_t) G__int(libp->para[0])));
20663 return(1 || funcname || hash || result7 || libp) ;
20664}
20665
20666static int G__RootEventData_rootcint_484_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20667{
20668 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20669 return(1 || funcname || hash || result7 || libp) ;
20670}
20671
20672static int G__RootEventData_rootcint_484_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20673{
20674 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelixP((Int_t) G__int(libp->para[0])));
20675 return(1 || funcname || hash || result7 || libp) ;
20676}
20677
20678static int G__RootEventData_rootcint_484_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20679{
20680 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20681 return(1 || funcname || hash || result7 || libp) ;
20682}
20683
20684static int G__RootEventData_rootcint_484_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20685{
20686 ((TMdcKalTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
20687 G__setnull(result7);
20688 return(1 || funcname || hash || result7 || libp) ;
20689}
20690
20691static int G__RootEventData_rootcint_484_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20692{
20693 ((TMdcKalTrack*) G__getstructoffset())->setStat((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
20694 G__setnull(result7);
20695 return(1 || funcname || hash || result7 || libp) ;
20696}
20697
20698static int G__RootEventData_rootcint_484_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20699{
20700 ((TMdcKalTrack*) G__getstructoffset())->setStat2((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
20701 G__setnull(result7);
20702 return(1 || funcname || hash || result7 || libp) ;
20703}
20704
20705static int G__RootEventData_rootcint_484_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20706{
20707 ((TMdcKalTrack*) G__getstructoffset())->setChisq((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
20708 G__setnull(result7);
20709 return(1 || funcname || hash || result7 || libp) ;
20710}
20711
20712static int G__RootEventData_rootcint_484_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20713{
20714 ((TMdcKalTrack*) G__getstructoffset())->setNdf((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
20715 G__setnull(result7);
20716 return(1 || funcname || hash || result7 || libp) ;
20717}
20718
20719static int G__RootEventData_rootcint_484_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20720{
20721 ((TMdcKalTrack*) G__getstructoffset())->setNlayer((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
20722 G__setnull(result7);
20723 return(1 || funcname || hash || result7 || libp) ;
20724}
20725
20726static int G__RootEventData_rootcint_484_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20727{
20728 ((TMdcKalTrack*) G__getstructoffset())->setZHelix((Double_t*) G__int(libp->para[0]));
20729 G__setnull(result7);
20730 return(1 || funcname || hash || result7 || libp) ;
20731}
20732
20733static int G__RootEventData_rootcint_484_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20734{
20735 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20736 ((TMdcKalTrack*) G__getstructoffset())->setZError(G__Ap0->a);
20737 G__setnull(result7);
20738 return(1 || funcname || hash || result7 || libp) ;
20739}
20740
20741static int G__RootEventData_rootcint_484_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20742{
20743 ((TMdcKalTrack*) G__getstructoffset())->setZHelixE((Double_t*) G__int(libp->para[0]));
20744 G__setnull(result7);
20745 return(1 || funcname || hash || result7 || libp) ;
20746}
20747
20748static int G__RootEventData_rootcint_484_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20749{
20750 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20751 ((TMdcKalTrack*) G__getstructoffset())->setZErrorE(G__Ap0->a);
20752 G__setnull(result7);
20753 return(1 || funcname || hash || result7 || libp) ;
20754}
20755
20756static int G__RootEventData_rootcint_484_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20757{
20758 ((TMdcKalTrack*) G__getstructoffset())->setZHelixMu((Double_t*) G__int(libp->para[0]));
20759 G__setnull(result7);
20760 return(1 || funcname || hash || result7 || libp) ;
20761}
20762
20763static int G__RootEventData_rootcint_484_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20764{
20765 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20766 ((TMdcKalTrack*) G__getstructoffset())->setZErrorMu(G__Ap0->a);
20767 G__setnull(result7);
20768 return(1 || funcname || hash || result7 || libp) ;
20769}
20770
20771static int G__RootEventData_rootcint_484_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20772{
20773 ((TMdcKalTrack*) G__getstructoffset())->setZHelixK((Double_t*) G__int(libp->para[0]));
20774 G__setnull(result7);
20775 return(1 || funcname || hash || result7 || libp) ;
20776}
20777
20778static int G__RootEventData_rootcint_484_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20779{
20780 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20781 ((TMdcKalTrack*) G__getstructoffset())->setZErrorK(G__Ap0->a);
20782 G__setnull(result7);
20783 return(1 || funcname || hash || result7 || libp) ;
20784}
20785
20786static int G__RootEventData_rootcint_484_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20787{
20788 ((TMdcKalTrack*) G__getstructoffset())->setZHelixP((Double_t*) G__int(libp->para[0]));
20789 G__setnull(result7);
20790 return(1 || funcname || hash || result7 || libp) ;
20791}
20792
20793static int G__RootEventData_rootcint_484_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20794{
20795 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20796 ((TMdcKalTrack*) G__getstructoffset())->setZErrorP(G__Ap0->a);
20797 G__setnull(result7);
20798 return(1 || funcname || hash || result7 || libp) ;
20799}
20800
20801static int G__RootEventData_rootcint_484_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20802{
20803 ((TMdcKalTrack*) G__getstructoffset())->setFHelix((Double_t*) G__int(libp->para[0]));
20804 G__setnull(result7);
20805 return(1 || funcname || hash || result7 || libp) ;
20806}
20807
20808static int G__RootEventData_rootcint_484_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20809{
20810 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20811 ((TMdcKalTrack*) G__getstructoffset())->setFError(G__Ap0->a);
20812 G__setnull(result7);
20813 return(1 || funcname || hash || result7 || libp) ;
20814}
20815
20816static int G__RootEventData_rootcint_484_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20817{
20818 ((TMdcKalTrack*) G__getstructoffset())->setFHelixE((Double_t*) G__int(libp->para[0]));
20819 G__setnull(result7);
20820 return(1 || funcname || hash || result7 || libp) ;
20821}
20822
20823static int G__RootEventData_rootcint_484_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20824{
20825 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20826 ((TMdcKalTrack*) G__getstructoffset())->setFErrorE(G__Ap0->a);
20827 G__setnull(result7);
20828 return(1 || funcname || hash || result7 || libp) ;
20829}
20830
20831static int G__RootEventData_rootcint_484_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20832{
20833 ((TMdcKalTrack*) G__getstructoffset())->setFHelixMu((Double_t*) G__int(libp->para[0]));
20834 G__setnull(result7);
20835 return(1 || funcname || hash || result7 || libp) ;
20836}
20837
20838static int G__RootEventData_rootcint_484_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20839{
20840 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20841 ((TMdcKalTrack*) G__getstructoffset())->setFErrorMu(G__Ap0->a);
20842 G__setnull(result7);
20843 return(1 || funcname || hash || result7 || libp) ;
20844}
20845
20846static int G__RootEventData_rootcint_484_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20847{
20848 ((TMdcKalTrack*) G__getstructoffset())->setFHelixK((Double_t*) G__int(libp->para[0]));
20849 G__setnull(result7);
20850 return(1 || funcname || hash || result7 || libp) ;
20851}
20852
20853static int G__RootEventData_rootcint_484_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20854{
20855 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20856 ((TMdcKalTrack*) G__getstructoffset())->setFErrorK(G__Ap0->a);
20857 G__setnull(result7);
20858 return(1 || funcname || hash || result7 || libp) ;
20859}
20860
20861static int G__RootEventData_rootcint_484_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20862{
20863 ((TMdcKalTrack*) G__getstructoffset())->setFHelixP((Double_t*) G__int(libp->para[0]));
20864 G__setnull(result7);
20865 return(1 || funcname || hash || result7 || libp) ;
20866}
20867
20868static int G__RootEventData_rootcint_484_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20869{
20870 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20871 ((TMdcKalTrack*) G__getstructoffset())->setFErrorP(G__Ap0->a);
20872 G__setnull(result7);
20873 return(1 || funcname || hash || result7 || libp) ;
20874}
20875
20876static int G__RootEventData_rootcint_484_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20877{
20878 G__letint(result7, 85, (long) TMdcKalTrack::Class());
20879 return(1 || funcname || hash || result7 || libp) ;
20880}
20881
20882static int G__RootEventData_rootcint_484_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20883{
20884 G__letint(result7, 67, (long) TMdcKalTrack::Class_Name());
20885 return(1 || funcname || hash || result7 || libp) ;
20886}
20887
20888static int G__RootEventData_rootcint_484_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20889{
20890 G__letint(result7, 115, (long) TMdcKalTrack::Class_Version());
20891 return(1 || funcname || hash || result7 || libp) ;
20892}
20893
20894static int G__RootEventData_rootcint_484_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20895{
20896 TMdcKalTrack::Dictionary();
20897 G__setnull(result7);
20898 return(1 || funcname || hash || result7 || libp) ;
20899}
20900
20901static int G__RootEventData_rootcint_484_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20902{
20903 ((TMdcKalTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
20904 G__setnull(result7);
20905 return(1 || funcname || hash || result7 || libp) ;
20906}
20907
20908static int G__RootEventData_rootcint_484_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20909{
20910 G__letint(result7, 67, (long) TMdcKalTrack::DeclFileName());
20911 return(1 || funcname || hash || result7 || libp) ;
20912}
20913
20914static int G__RootEventData_rootcint_484_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20915{
20916 G__letint(result7, 105, (long) TMdcKalTrack::ImplFileLine());
20917 return(1 || funcname || hash || result7 || libp) ;
20918}
20919
20920static int G__RootEventData_rootcint_484_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20921{
20922 G__letint(result7, 67, (long) TMdcKalTrack::ImplFileName());
20923 return(1 || funcname || hash || result7 || libp) ;
20924}
20925
20926static int G__RootEventData_rootcint_484_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20927{
20928 G__letint(result7, 105, (long) TMdcKalTrack::DeclFileLine());
20929 return(1 || funcname || hash || result7 || libp) ;
20930}
20931
20932// automatic copy constructor
20933static int G__RootEventData_rootcint_484_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20934
20935{
20936 TMdcKalTrack* p;
20937 void* tmp = (void*) G__int(libp->para[0]);
20938 p = new TMdcKalTrack(*(TMdcKalTrack*) tmp);
20939 result7->obj.i = (long) p;
20940 result7->ref = (long) p;
20941 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack));
20942 return(1 || funcname || hash || result7 || libp) ;
20943}
20944
20945// automatic destructor
20946typedef TMdcKalTrack G__TTMdcKalTrack;
20947static int G__RootEventData_rootcint_484_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20948{
20949 char* gvp = (char*) G__getgvp();
20950 long soff = G__getstructoffset();
20951 int n = G__getaryconstruct();
20952 //
20953 //has_a_delete: 1
20954 //has_own_delete1arg: 0
20955 //has_own_delete2arg: 0
20956 //
20957 if (!soff) {
20958 return(1);
20959 }
20960 if (n) {
20961 if (gvp == (char*)G__PVOID) {
20962 delete[] (TMdcKalTrack*) soff;
20963 } else {
20964 G__setgvp((long) G__PVOID);
20965 for (int i = n - 1; i >= 0; --i) {
20966 ((TMdcKalTrack*) (soff+(sizeof(TMdcKalTrack)*i)))->~G__TTMdcKalTrack();
20967 }
20968 G__setgvp((long)gvp);
20969 }
20970 } else {
20971 if (gvp == (char*)G__PVOID) {
20972 delete (TMdcKalTrack*) soff;
20973 } else {
20974 G__setgvp((long) G__PVOID);
20975 ((TMdcKalTrack*) (soff))->~G__TTMdcKalTrack();
20976 G__setgvp((long)gvp);
20977 }
20978 }
20979 G__setnull(result7);
20980 return(1 || funcname || hash || result7 || libp) ;
20981}
20982
20983// automatic assignment operator
20984static int G__RootEventData_rootcint_484_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20985{
20986 TMdcKalTrack* dest = (TMdcKalTrack*) G__getstructoffset();
20987 *dest = *(TMdcKalTrack*) libp->para[0].ref;
20988 const TMdcKalTrack& obj = *dest;
20989 result7->ref = (long) (&obj);
20990 result7->obj.i = (long) (&obj);
20991 return(1 || funcname || hash || result7 || libp) ;
20992}
20993
20994
20995/* TDstEvent */
20996static int G__RootEventData_rootcint_485_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20997{
20998 TDstEvent* p = NULL;
20999 char* gvp = (char*) G__getgvp();
21000 int n = G__getaryconstruct();
21001 if (n) {
21002 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21003 p = new TDstEvent[n];
21004 } else {
21005 p = new((void*) gvp) TDstEvent[n];
21006 }
21007 } else {
21008 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21009 p = new TDstEvent;
21010 } else {
21011 p = new((void*) gvp) TDstEvent;
21012 }
21013 }
21014 result7->obj.i = (long) p;
21015 result7->ref = (long) p;
21016 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent));
21017 return(1 || funcname || hash || result7 || libp) ;
21018}
21019
21020static int G__RootEventData_rootcint_485_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21021{
21022 ((TDstEvent*) G__getstructoffset())->initialize();
21023 G__setnull(result7);
21024 return(1 || funcname || hash || result7 || libp) ;
21025}
21026
21027static int G__RootEventData_rootcint_485_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21028{
21029 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcTrackCol());
21030 return(1 || funcname || hash || result7 || libp) ;
21031}
21032
21033static int G__RootEventData_rootcint_485_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21034{
21035 ((TDstEvent*) G__getstructoffset())->addMdcTrack((TMdcTrack*) G__int(libp->para[0]));
21036 G__setnull(result7);
21037 return(1 || funcname || hash || result7 || libp) ;
21038}
21039
21040static int G__RootEventData_rootcint_485_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21041{
21042 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcTrack((Int_t) G__int(libp->para[0])));
21043 return(1 || funcname || hash || result7 || libp) ;
21044}
21045
21046static int G__RootEventData_rootcint_485_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21047{
21048 ((TDstEvent*) G__getstructoffset())->clearMdcTrackCol();
21049 G__setnull(result7);
21050 return(1 || funcname || hash || result7 || libp) ;
21051}
21052
21053static int G__RootEventData_rootcint_485_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21054{
21055 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getEmcTrackCol());
21056 return(1 || funcname || hash || result7 || libp) ;
21057}
21058
21059static int G__RootEventData_rootcint_485_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21060{
21061 ((TDstEvent*) G__getstructoffset())->addEmcTrack((TEmcTrack*) G__int(libp->para[0]));
21062 G__setnull(result7);
21063 return(1 || funcname || hash || result7 || libp) ;
21064}
21065
21066static int G__RootEventData_rootcint_485_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21067{
21068 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getEmcTrack((Int_t) G__int(libp->para[0])));
21069 return(1 || funcname || hash || result7 || libp) ;
21070}
21071
21072static int G__RootEventData_rootcint_485_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21073{
21074 ((TDstEvent*) G__getstructoffset())->clearEmcTrackCol();
21075 G__setnull(result7);
21076 return(1 || funcname || hash || result7 || libp) ;
21077}
21078
21079static int G__RootEventData_rootcint_485_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21080{
21081 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getTofTrackCol());
21082 return(1 || funcname || hash || result7 || libp) ;
21083}
21084
21085static int G__RootEventData_rootcint_485_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21086{
21087 ((TDstEvent*) G__getstructoffset())->addTofTrack((TTofTrack*) G__int(libp->para[0]));
21088 G__setnull(result7);
21089 return(1 || funcname || hash || result7 || libp) ;
21090}
21091
21092static int G__RootEventData_rootcint_485_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21093{
21094 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getTofTrack((Int_t) G__int(libp->para[0])));
21095 return(1 || funcname || hash || result7 || libp) ;
21096}
21097
21098static int G__RootEventData_rootcint_485_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21099{
21100 ((TDstEvent*) G__getstructoffset())->clearTofTrackCol();
21101 G__setnull(result7);
21102 return(1 || funcname || hash || result7 || libp) ;
21103}
21104
21105static int G__RootEventData_rootcint_485_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21106{
21107 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMucTrackCol());
21108 return(1 || funcname || hash || result7 || libp) ;
21109}
21110
21111static int G__RootEventData_rootcint_485_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21112{
21113 ((TDstEvent*) G__getstructoffset())->addMucTrack((TMucTrack*) G__int(libp->para[0]));
21114 G__setnull(result7);
21115 return(1 || funcname || hash || result7 || libp) ;
21116}
21117
21118static int G__RootEventData_rootcint_485_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21119{
21120 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMucTrack((Int_t) G__int(libp->para[0])));
21121 return(1 || funcname || hash || result7 || libp) ;
21122}
21123
21124static int G__RootEventData_rootcint_485_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21125{
21126 ((TDstEvent*) G__getstructoffset())->clearMucTrackCol();
21127 G__setnull(result7);
21128 return(1 || funcname || hash || result7 || libp) ;
21129}
21130
21131static int G__RootEventData_rootcint_485_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21132{
21133 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcDedxCol());
21134 return(1 || funcname || hash || result7 || libp) ;
21135}
21136
21137static int G__RootEventData_rootcint_485_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21138{
21139 ((TDstEvent*) G__getstructoffset())->addMdcDedx((TMdcDedx*) G__int(libp->para[0]));
21140 G__setnull(result7);
21141 return(1 || funcname || hash || result7 || libp) ;
21142}
21143
21144static int G__RootEventData_rootcint_485_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21145{
21146 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcDedx((Int_t) G__int(libp->para[0])));
21147 return(1 || funcname || hash || result7 || libp) ;
21148}
21149
21150static int G__RootEventData_rootcint_485_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21151{
21152 ((TDstEvent*) G__getstructoffset())->clearMdcDedxCol();
21153 G__setnull(result7);
21154 return(1 || funcname || hash || result7 || libp) ;
21155}
21156
21157static int G__RootEventData_rootcint_485_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21158{
21159 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getExtTrackCol());
21160 return(1 || funcname || hash || result7 || libp) ;
21161}
21162
21163static int G__RootEventData_rootcint_485_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21164{
21165 ((TDstEvent*) G__getstructoffset())->addExtTrack((TExtTrack*) G__int(libp->para[0]));
21166 G__setnull(result7);
21167 return(1 || funcname || hash || result7 || libp) ;
21168}
21169
21170static int G__RootEventData_rootcint_485_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21171{
21172 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getExtTrack((Int_t) G__int(libp->para[0])));
21173 return(1 || funcname || hash || result7 || libp) ;
21174}
21175
21176static int G__RootEventData_rootcint_485_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21177{
21178 ((TDstEvent*) G__getstructoffset())->clearExtTrackCol();
21179 G__setnull(result7);
21180 return(1 || funcname || hash || result7 || libp) ;
21181}
21182
21183static int G__RootEventData_rootcint_485_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21184{
21185 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcKalTrackCol());
21186 return(1 || funcname || hash || result7 || libp) ;
21187}
21188
21189static int G__RootEventData_rootcint_485_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21190{
21191 ((TDstEvent*) G__getstructoffset())->addMdcKalTrack((TMdcKalTrack*) G__int(libp->para[0]));
21192 G__setnull(result7);
21193 return(1 || funcname || hash || result7 || libp) ;
21194}
21195
21196static int G__RootEventData_rootcint_485_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21197{
21198 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcKalTrack((Int_t) G__int(libp->para[0])));
21199 return(1 || funcname || hash || result7 || libp) ;
21200}
21201
21202static int G__RootEventData_rootcint_485_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21203{
21204 ((TDstEvent*) G__getstructoffset())->clearMdcKalTrackCol();
21205 G__setnull(result7);
21206 return(1 || funcname || hash || result7 || libp) ;
21207}
21208
21209static int G__RootEventData_rootcint_485_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21210{
21211 G__letint(result7, 85, (long) TDstEvent::Class());
21212 return(1 || funcname || hash || result7 || libp) ;
21213}
21214
21215static int G__RootEventData_rootcint_485_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21216{
21217 G__letint(result7, 67, (long) TDstEvent::Class_Name());
21218 return(1 || funcname || hash || result7 || libp) ;
21219}
21220
21221static int G__RootEventData_rootcint_485_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21222{
21223 G__letint(result7, 115, (long) TDstEvent::Class_Version());
21224 return(1 || funcname || hash || result7 || libp) ;
21225}
21226
21227static int G__RootEventData_rootcint_485_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21228{
21229 TDstEvent::Dictionary();
21230 G__setnull(result7);
21231 return(1 || funcname || hash || result7 || libp) ;
21232}
21233
21234static int G__RootEventData_rootcint_485_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21235{
21236 ((TDstEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
21237 G__setnull(result7);
21238 return(1 || funcname || hash || result7 || libp) ;
21239}
21240
21241static int G__RootEventData_rootcint_485_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21242{
21243 G__letint(result7, 67, (long) TDstEvent::DeclFileName());
21244 return(1 || funcname || hash || result7 || libp) ;
21245}
21246
21247static int G__RootEventData_rootcint_485_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21248{
21249 G__letint(result7, 105, (long) TDstEvent::ImplFileLine());
21250 return(1 || funcname || hash || result7 || libp) ;
21251}
21252
21253static int G__RootEventData_rootcint_485_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21254{
21255 G__letint(result7, 67, (long) TDstEvent::ImplFileName());
21256 return(1 || funcname || hash || result7 || libp) ;
21257}
21258
21259static int G__RootEventData_rootcint_485_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21260{
21261 G__letint(result7, 105, (long) TDstEvent::DeclFileLine());
21262 return(1 || funcname || hash || result7 || libp) ;
21263}
21264
21265// automatic copy constructor
21266static int G__RootEventData_rootcint_485_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21267
21268{
21269 TDstEvent* p;
21270 void* tmp = (void*) G__int(libp->para[0]);
21271 p = new TDstEvent(*(TDstEvent*) tmp);
21272 result7->obj.i = (long) p;
21273 result7->ref = (long) p;
21274 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent));
21275 return(1 || funcname || hash || result7 || libp) ;
21276}
21277
21278// automatic destructor
21279typedef TDstEvent G__TTDstEvent;
21280static int G__RootEventData_rootcint_485_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21281{
21282 char* gvp = (char*) G__getgvp();
21283 long soff = G__getstructoffset();
21284 int n = G__getaryconstruct();
21285 //
21286 //has_a_delete: 1
21287 //has_own_delete1arg: 0
21288 //has_own_delete2arg: 0
21289 //
21290 if (!soff) {
21291 return(1);
21292 }
21293 if (n) {
21294 if (gvp == (char*)G__PVOID) {
21295 delete[] (TDstEvent*) soff;
21296 } else {
21297 G__setgvp((long) G__PVOID);
21298 for (int i = n - 1; i >= 0; --i) {
21299 ((TDstEvent*) (soff+(sizeof(TDstEvent)*i)))->~G__TTDstEvent();
21300 }
21301 G__setgvp((long)gvp);
21302 }
21303 } else {
21304 if (gvp == (char*)G__PVOID) {
21305 delete (TDstEvent*) soff;
21306 } else {
21307 G__setgvp((long) G__PVOID);
21308 ((TDstEvent*) (soff))->~G__TTDstEvent();
21309 G__setgvp((long)gvp);
21310 }
21311 }
21312 G__setnull(result7);
21313 return(1 || funcname || hash || result7 || libp) ;
21314}
21315
21316// automatic assignment operator
21317static int G__RootEventData_rootcint_485_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21318{
21319 TDstEvent* dest = (TDstEvent*) G__getstructoffset();
21320 *dest = *(TDstEvent*) libp->para[0].ref;
21321 const TDstEvent& obj = *dest;
21322 result7->ref = (long) (&obj);
21323 result7->obj.i = (long) (&obj);
21324 return(1 || funcname || hash || result7 || libp) ;
21325}
21326
21327
21328/* TMdcMc */
21329static int G__RootEventData_rootcint_486_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21330{
21331 TMdcMc* p = NULL;
21332 char* gvp = (char*) G__getgvp();
21333 int n = G__getaryconstruct();
21334 if (n) {
21335 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21336 p = new TMdcMc[n];
21337 } else {
21338 p = new((void*) gvp) TMdcMc[n];
21339 }
21340 } else {
21341 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21342 p = new TMdcMc;
21343 } else {
21344 p = new((void*) gvp) TMdcMc;
21345 }
21346 }
21347 result7->obj.i = (long) p;
21348 result7->ref = (long) p;
21349 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc));
21350 return(1 || funcname || hash || result7 || libp) ;
21351}
21352
21353static int G__RootEventData_rootcint_486_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21354{
21355 G__letint(result7, 104, (long) ((const TMdcMc*) G__getstructoffset())->getId());
21356 return(1 || funcname || hash || result7 || libp) ;
21357}
21358
21359static int G__RootEventData_rootcint_486_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21360{
21361 G__letint(result7, 104, (long) ((const TMdcMc*) G__getstructoffset())->getTrackIndex());
21362 return(1 || funcname || hash || result7 || libp) ;
21363}
21364
21365static int G__RootEventData_rootcint_486_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21366{
21367 G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getPositionX());
21368 return(1 || funcname || hash || result7 || libp) ;
21369}
21370
21371static int G__RootEventData_rootcint_486_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21372{
21373 G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getPositionY());
21374 return(1 || funcname || hash || result7 || libp) ;
21375}
21376
21377static int G__RootEventData_rootcint_486_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21378{
21379 G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getPositionZ());
21380 return(1 || funcname || hash || result7 || libp) ;
21381}
21382
21383static int G__RootEventData_rootcint_486_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21384{
21385 G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getDriftDistance());
21386 return(1 || funcname || hash || result7 || libp) ;
21387}
21388
21389static int G__RootEventData_rootcint_486_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21390{
21391 G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getDepositEnergy());
21392 return(1 || funcname || hash || result7 || libp) ;
21393}
21394
21395static int G__RootEventData_rootcint_486_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21396{
21397 G__letint(result7, 105, (long) ((const TMdcMc*) G__getstructoffset())->getPositionFlag());
21398 return(1 || funcname || hash || result7 || libp) ;
21399}
21400
21401static int G__RootEventData_rootcint_486_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21402{
21403 ((TMdcMc*) G__getstructoffset())->setId((UInt_t) G__int(libp->para[0]));
21404 G__setnull(result7);
21405 return(1 || funcname || hash || result7 || libp) ;
21406}
21407
21408static int G__RootEventData_rootcint_486_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21409{
21410 ((TMdcMc*) G__getstructoffset())->setTrackIndex((UInt_t) G__int(libp->para[0]));
21411 G__setnull(result7);
21412 return(1 || funcname || hash || result7 || libp) ;
21413}
21414
21415static int G__RootEventData_rootcint_486_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21416{
21417 ((TMdcMc*) G__getstructoffset())->setPositionX((Double_t) G__double(libp->para[0]));
21418 G__setnull(result7);
21419 return(1 || funcname || hash || result7 || libp) ;
21420}
21421
21422static int G__RootEventData_rootcint_486_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21423{
21424 ((TMdcMc*) G__getstructoffset())->setPositionY((Double_t) G__double(libp->para[0]));
21425 G__setnull(result7);
21426 return(1 || funcname || hash || result7 || libp) ;
21427}
21428
21429static int G__RootEventData_rootcint_486_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21430{
21431 ((TMdcMc*) G__getstructoffset())->setPositionZ((Double_t) G__double(libp->para[0]));
21432 G__setnull(result7);
21433 return(1 || funcname || hash || result7 || libp) ;
21434}
21435
21436static int G__RootEventData_rootcint_486_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21437{
21438 ((TMdcMc*) G__getstructoffset())->setDriftDistance((Double_t) G__double(libp->para[0]));
21439 G__setnull(result7);
21440 return(1 || funcname || hash || result7 || libp) ;
21441}
21442
21443static int G__RootEventData_rootcint_486_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21444{
21445 ((TMdcMc*) G__getstructoffset())->setDepositEnergy((Double_t) G__double(libp->para[0]));
21446 G__setnull(result7);
21447 return(1 || funcname || hash || result7 || libp) ;
21448}
21449
21450static int G__RootEventData_rootcint_486_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21451{
21452 ((TMdcMc*) G__getstructoffset())->setPositionFlag((Int_t) G__int(libp->para[0]));
21453 G__setnull(result7);
21454 return(1 || funcname || hash || result7 || libp) ;
21455}
21456
21457static int G__RootEventData_rootcint_486_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21458{
21459 G__letint(result7, 85, (long) TMdcMc::Class());
21460 return(1 || funcname || hash || result7 || libp) ;
21461}
21462
21463static int G__RootEventData_rootcint_486_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21464{
21465 G__letint(result7, 67, (long) TMdcMc::Class_Name());
21466 return(1 || funcname || hash || result7 || libp) ;
21467}
21468
21469static int G__RootEventData_rootcint_486_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21470{
21471 G__letint(result7, 115, (long) TMdcMc::Class_Version());
21472 return(1 || funcname || hash || result7 || libp) ;
21473}
21474
21475static int G__RootEventData_rootcint_486_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21476{
21477 TMdcMc::Dictionary();
21478 G__setnull(result7);
21479 return(1 || funcname || hash || result7 || libp) ;
21480}
21481
21482static int G__RootEventData_rootcint_486_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21483{
21484 ((TMdcMc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
21485 G__setnull(result7);
21486 return(1 || funcname || hash || result7 || libp) ;
21487}
21488
21489static int G__RootEventData_rootcint_486_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21490{
21491 G__letint(result7, 67, (long) TMdcMc::DeclFileName());
21492 return(1 || funcname || hash || result7 || libp) ;
21493}
21494
21495static int G__RootEventData_rootcint_486_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21496{
21497 G__letint(result7, 105, (long) TMdcMc::ImplFileLine());
21498 return(1 || funcname || hash || result7 || libp) ;
21499}
21500
21501static int G__RootEventData_rootcint_486_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21502{
21503 G__letint(result7, 67, (long) TMdcMc::ImplFileName());
21504 return(1 || funcname || hash || result7 || libp) ;
21505}
21506
21507static int G__RootEventData_rootcint_486_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21508{
21509 G__letint(result7, 105, (long) TMdcMc::DeclFileLine());
21510 return(1 || funcname || hash || result7 || libp) ;
21511}
21512
21513// automatic copy constructor
21514static int G__RootEventData_rootcint_486_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21515
21516{
21517 TMdcMc* p;
21518 void* tmp = (void*) G__int(libp->para[0]);
21519 p = new TMdcMc(*(TMdcMc*) tmp);
21520 result7->obj.i = (long) p;
21521 result7->ref = (long) p;
21522 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc));
21523 return(1 || funcname || hash || result7 || libp) ;
21524}
21525
21526// automatic destructor
21527typedef TMdcMc G__TTMdcMc;
21528static int G__RootEventData_rootcint_486_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21529{
21530 char* gvp = (char*) G__getgvp();
21531 long soff = G__getstructoffset();
21532 int n = G__getaryconstruct();
21533 //
21534 //has_a_delete: 1
21535 //has_own_delete1arg: 0
21536 //has_own_delete2arg: 0
21537 //
21538 if (!soff) {
21539 return(1);
21540 }
21541 if (n) {
21542 if (gvp == (char*)G__PVOID) {
21543 delete[] (TMdcMc*) soff;
21544 } else {
21545 G__setgvp((long) G__PVOID);
21546 for (int i = n - 1; i >= 0; --i) {
21547 ((TMdcMc*) (soff+(sizeof(TMdcMc)*i)))->~G__TTMdcMc();
21548 }
21549 G__setgvp((long)gvp);
21550 }
21551 } else {
21552 if (gvp == (char*)G__PVOID) {
21553 delete (TMdcMc*) soff;
21554 } else {
21555 G__setgvp((long) G__PVOID);
21556 ((TMdcMc*) (soff))->~G__TTMdcMc();
21557 G__setgvp((long)gvp);
21558 }
21559 }
21560 G__setnull(result7);
21561 return(1 || funcname || hash || result7 || libp) ;
21562}
21563
21564// automatic assignment operator
21565static int G__RootEventData_rootcint_486_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21566{
21567 TMdcMc* dest = (TMdcMc*) G__getstructoffset();
21568 *dest = *(TMdcMc*) libp->para[0].ref;
21569 const TMdcMc& obj = *dest;
21570 result7->ref = (long) (&obj);
21571 result7->obj.i = (long) (&obj);
21572 return(1 || funcname || hash || result7 || libp) ;
21573}
21574
21575
21576/* TEmcMc */
21577static int G__RootEventData_rootcint_487_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21578{
21579 TEmcMc* p = NULL;
21580 char* gvp = (char*) G__getgvp();
21581 int n = G__getaryconstruct();
21582 if (n) {
21583 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21584 p = new TEmcMc[n];
21585 } else {
21586 p = new((void*) gvp) TEmcMc[n];
21587 }
21588 } else {
21589 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21590 p = new TEmcMc;
21591 } else {
21592 p = new((void*) gvp) TEmcMc;
21593 }
21594 }
21595 result7->obj.i = (long) p;
21596 result7->ref = (long) p;
21597 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc));
21598 return(1 || funcname || hash || result7 || libp) ;
21599}
21600
21601static int G__RootEventData_rootcint_487_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21602{
21603 {
21604 const map<Int_t,Double_t>* pobj;
21605 const map<Int_t,Double_t> xobj = ((const TEmcMc*) G__getstructoffset())->getHitMap();
21606 pobj = new map<Int_t,Double_t>(xobj);
21607 result7->obj.i = (long) ((void*) pobj);
21608 result7->ref = result7->obj.i;
21609 G__store_tempobject(*result7);
21610 }
21611 return(1 || funcname || hash || result7 || libp) ;
21612}
21613
21614static int G__RootEventData_rootcint_487_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21615{
21616 G__letint(result7, 105, (long) ((const TEmcMc*) G__getstructoffset())->getHitEmc());
21617 return(1 || funcname || hash || result7 || libp) ;
21618}
21619
21620static int G__RootEventData_rootcint_487_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21621{
21622 G__letint(result7, 105, (long) ((const TEmcMc*) G__getstructoffset())->getPDGCode());
21623 return(1 || funcname || hash || result7 || libp) ;
21624}
21625
21626static int G__RootEventData_rootcint_487_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21627{
21628 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPDGCharge());
21629 return(1 || funcname || hash || result7 || libp) ;
21630}
21631
21632static int G__RootEventData_rootcint_487_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21633{
21634 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getTime());
21635 return(1 || funcname || hash || result7 || libp) ;
21636}
21637
21638static int G__RootEventData_rootcint_487_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21639{
21640 G__letint(result7, 104, (long) ((const TEmcMc*) G__getstructoffset())->getId());
21641 return(1 || funcname || hash || result7 || libp) ;
21642}
21643
21644static int G__RootEventData_rootcint_487_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21645{
21646 G__letint(result7, 104, (long) ((const TEmcMc*) G__getstructoffset())->getTrackIndex());
21647 return(1 || funcname || hash || result7 || libp) ;
21648}
21649
21650static int G__RootEventData_rootcint_487_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21651{
21652 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPositionX());
21653 return(1 || funcname || hash || result7 || libp) ;
21654}
21655
21656static int G__RootEventData_rootcint_487_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21657{
21658 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPositionY());
21659 return(1 || funcname || hash || result7 || libp) ;
21660}
21661
21662static int G__RootEventData_rootcint_487_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21663{
21664 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPositionZ());
21665 return(1 || funcname || hash || result7 || libp) ;
21666}
21667
21668static int G__RootEventData_rootcint_487_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21669{
21670 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPx());
21671 return(1 || funcname || hash || result7 || libp) ;
21672}
21673
21674static int G__RootEventData_rootcint_487_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21675{
21676 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPy());
21677 return(1 || funcname || hash || result7 || libp) ;
21678}
21679
21680static int G__RootEventData_rootcint_487_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21681{
21682 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPz());
21683 return(1 || funcname || hash || result7 || libp) ;
21684}
21685
21686static int G__RootEventData_rootcint_487_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21687{
21688 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getDepositEnergy());
21689 return(1 || funcname || hash || result7 || libp) ;
21690}
21691
21692static int G__RootEventData_rootcint_487_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21693{
21694 ((TEmcMc*) G__getstructoffset())->setHitMap(*((map<Int_t,Double_t>*) G__int(libp->para[0])));
21695 G__setnull(result7);
21696 return(1 || funcname || hash || result7 || libp) ;
21697}
21698
21699static int G__RootEventData_rootcint_487_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21700{
21701 ((TEmcMc*) G__getstructoffset())->setHitEmc((int) G__int(libp->para[0]));
21702 G__setnull(result7);
21703 return(1 || funcname || hash || result7 || libp) ;
21704}
21705
21706static int G__RootEventData_rootcint_487_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21707{
21708 ((TEmcMc*) G__getstructoffset())->setPDGCode((int) G__int(libp->para[0]));
21709 G__setnull(result7);
21710 return(1 || funcname || hash || result7 || libp) ;
21711}
21712
21713static int G__RootEventData_rootcint_487_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21714{
21715 ((TEmcMc*) G__getstructoffset())->setPDGCharge((double) G__double(libp->para[0]));
21716 G__setnull(result7);
21717 return(1 || funcname || hash || result7 || libp) ;
21718}
21719
21720static int G__RootEventData_rootcint_487_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21721{
21722 ((TEmcMc*) G__getstructoffset())->setTime((double) G__double(libp->para[0]));
21723 G__setnull(result7);
21724 return(1 || funcname || hash || result7 || libp) ;
21725}
21726
21727static int G__RootEventData_rootcint_487_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21728{
21729 ((TEmcMc*) G__getstructoffset())->setId((UInt_t) G__int(libp->para[0]));
21730 G__setnull(result7);
21731 return(1 || funcname || hash || result7 || libp) ;
21732}
21733
21734static int G__RootEventData_rootcint_487_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21735{
21736 ((TEmcMc*) G__getstructoffset())->setTrackIndex((UInt_t) G__int(libp->para[0]));
21737 G__setnull(result7);
21738 return(1 || funcname || hash || result7 || libp) ;
21739}
21740
21741static int G__RootEventData_rootcint_487_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21742{
21743 ((TEmcMc*) G__getstructoffset())->setPositionX((Double_t) G__double(libp->para[0]));
21744 G__setnull(result7);
21745 return(1 || funcname || hash || result7 || libp) ;
21746}
21747
21748static int G__RootEventData_rootcint_487_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21749{
21750 ((TEmcMc*) G__getstructoffset())->setPositionY((Double_t) G__double(libp->para[0]));
21751 G__setnull(result7);
21752 return(1 || funcname || hash || result7 || libp) ;
21753}
21754
21755static int G__RootEventData_rootcint_487_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21756{
21757 ((TEmcMc*) G__getstructoffset())->setPositionZ((Double_t) G__double(libp->para[0]));
21758 G__setnull(result7);
21759 return(1 || funcname || hash || result7 || libp) ;
21760}
21761
21762static int G__RootEventData_rootcint_487_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21763{
21764 ((TEmcMc*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
21765 G__setnull(result7);
21766 return(1 || funcname || hash || result7 || libp) ;
21767}
21768
21769static int G__RootEventData_rootcint_487_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21770{
21771 ((TEmcMc*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
21772 G__setnull(result7);
21773 return(1 || funcname || hash || result7 || libp) ;
21774}
21775
21776static int G__RootEventData_rootcint_487_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21777{
21778 ((TEmcMc*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
21779 G__setnull(result7);
21780 return(1 || funcname || hash || result7 || libp) ;
21781}
21782
21783static int G__RootEventData_rootcint_487_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21784{
21785 ((TEmcMc*) G__getstructoffset())->setDepositEnergy((Double_t) G__double(libp->para[0]));
21786 G__setnull(result7);
21787 return(1 || funcname || hash || result7 || libp) ;
21788}
21789
21790static int G__RootEventData_rootcint_487_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21791{
21792 G__letint(result7, 85, (long) TEmcMc::Class());
21793 return(1 || funcname || hash || result7 || libp) ;
21794}
21795
21796static int G__RootEventData_rootcint_487_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21797{
21798 G__letint(result7, 67, (long) TEmcMc::Class_Name());
21799 return(1 || funcname || hash || result7 || libp) ;
21800}
21801
21802static int G__RootEventData_rootcint_487_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21803{
21804 G__letint(result7, 115, (long) TEmcMc::Class_Version());
21805 return(1 || funcname || hash || result7 || libp) ;
21806}
21807
21808static int G__RootEventData_rootcint_487_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21809{
21810 TEmcMc::Dictionary();
21811 G__setnull(result7);
21812 return(1 || funcname || hash || result7 || libp) ;
21813}
21814
21815static int G__RootEventData_rootcint_487_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21816{
21817 ((TEmcMc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
21818 G__setnull(result7);
21819 return(1 || funcname || hash || result7 || libp) ;
21820}
21821
21822static int G__RootEventData_rootcint_487_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21823{
21824 G__letint(result7, 67, (long) TEmcMc::DeclFileName());
21825 return(1 || funcname || hash || result7 || libp) ;
21826}
21827
21828static int G__RootEventData_rootcint_487_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21829{
21830 G__letint(result7, 105, (long) TEmcMc::ImplFileLine());
21831 return(1 || funcname || hash || result7 || libp) ;
21832}
21833
21834static int G__RootEventData_rootcint_487_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21835{
21836 G__letint(result7, 67, (long) TEmcMc::ImplFileName());
21837 return(1 || funcname || hash || result7 || libp) ;
21838}
21839
21840static int G__RootEventData_rootcint_487_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21841{
21842 G__letint(result7, 105, (long) TEmcMc::DeclFileLine());
21843 return(1 || funcname || hash || result7 || libp) ;
21844}
21845
21846// automatic copy constructor
21847static int G__RootEventData_rootcint_487_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21848
21849{
21850 TEmcMc* p;
21851 void* tmp = (void*) G__int(libp->para[0]);
21852 p = new TEmcMc(*(TEmcMc*) tmp);
21853 result7->obj.i = (long) p;
21854 result7->ref = (long) p;
21855 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc));
21856 return(1 || funcname || hash || result7 || libp) ;
21857}
21858
21859// automatic destructor
21860typedef TEmcMc G__TTEmcMc;
21861static int G__RootEventData_rootcint_487_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21862{
21863 char* gvp = (char*) G__getgvp();
21864 long soff = G__getstructoffset();
21865 int n = G__getaryconstruct();
21866 //
21867 //has_a_delete: 1
21868 //has_own_delete1arg: 0
21869 //has_own_delete2arg: 0
21870 //
21871 if (!soff) {
21872 return(1);
21873 }
21874 if (n) {
21875 if (gvp == (char*)G__PVOID) {
21876 delete[] (TEmcMc*) soff;
21877 } else {
21878 G__setgvp((long) G__PVOID);
21879 for (int i = n - 1; i >= 0; --i) {
21880 ((TEmcMc*) (soff+(sizeof(TEmcMc)*i)))->~G__TTEmcMc();
21881 }
21882 G__setgvp((long)gvp);
21883 }
21884 } else {
21885 if (gvp == (char*)G__PVOID) {
21886 delete (TEmcMc*) soff;
21887 } else {
21888 G__setgvp((long) G__PVOID);
21889 ((TEmcMc*) (soff))->~G__TTEmcMc();
21890 G__setgvp((long)gvp);
21891 }
21892 }
21893 G__setnull(result7);
21894 return(1 || funcname || hash || result7 || libp) ;
21895}
21896
21897// automatic assignment operator
21898static int G__RootEventData_rootcint_487_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21899{
21900 TEmcMc* dest = (TEmcMc*) G__getstructoffset();
21901 *dest = *(TEmcMc*) libp->para[0].ref;
21902 const TEmcMc& obj = *dest;
21903 result7->ref = (long) (&obj);
21904 result7->obj.i = (long) (&obj);
21905 return(1 || funcname || hash || result7 || libp) ;
21906}
21907
21908
21909/* TTofMc */
21910static int G__RootEventData_rootcint_488_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21911{
21912 TTofMc* p = NULL;
21913 char* gvp = (char*) G__getgvp();
21914 int n = G__getaryconstruct();
21915 if (n) {
21916 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21917 p = new TTofMc[n];
21918 } else {
21919 p = new((void*) gvp) TTofMc[n];
21920 }
21921 } else {
21922 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21923 p = new TTofMc;
21924 } else {
21925 p = new((void*) gvp) TTofMc;
21926 }
21927 }
21928 result7->obj.i = (long) p;
21929 result7->ref = (long) p;
21930 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc));
21931 return(1 || funcname || hash || result7 || libp) ;
21932}
21933
21934static int G__RootEventData_rootcint_488_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21935{
21936 G__letint(result7, 104, (long) ((const TTofMc*) G__getstructoffset())->getId());
21937 return(1 || funcname || hash || result7 || libp) ;
21938}
21939
21940static int G__RootEventData_rootcint_488_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21941{
21942 G__letint(result7, 104, (long) ((const TTofMc*) G__getstructoffset())->getTrackIndex());
21943 return(1 || funcname || hash || result7 || libp) ;
21944}
21945
21946static int G__RootEventData_rootcint_488_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21947{
21948 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPositionX());
21949 return(1 || funcname || hash || result7 || libp) ;
21950}
21951
21952static int G__RootEventData_rootcint_488_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21953{
21954 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPositionY());
21955 return(1 || funcname || hash || result7 || libp) ;
21956}
21957
21958static int G__RootEventData_rootcint_488_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21959{
21960 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPositionZ());
21961 return(1 || funcname || hash || result7 || libp) ;
21962}
21963
21964static int G__RootEventData_rootcint_488_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21965{
21966 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPx());
21967 return(1 || funcname || hash || result7 || libp) ;
21968}
21969
21970static int G__RootEventData_rootcint_488_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21971{
21972 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPy());
21973 return(1 || funcname || hash || result7 || libp) ;
21974}
21975
21976static int G__RootEventData_rootcint_488_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21977{
21978 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPz());
21979 return(1 || funcname || hash || result7 || libp) ;
21980}
21981
21982static int G__RootEventData_rootcint_488_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21983{
21984 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getTrackLength());
21985 return(1 || funcname || hash || result7 || libp) ;
21986}
21987
21988static int G__RootEventData_rootcint_488_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21989{
21990 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getFlightTime());
21991 return(1 || funcname || hash || result7 || libp) ;
21992}
21993
21994static int G__RootEventData_rootcint_488_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21995{
21996 ((TTofMc*) G__getstructoffset())->setId((UInt_t) G__int(libp->para[0]));
21997 G__setnull(result7);
21998 return(1 || funcname || hash || result7 || libp) ;
21999}
22000
22001static int G__RootEventData_rootcint_488_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22002{
22003 ((TTofMc*) G__getstructoffset())->setTrackIndex((UInt_t) G__int(libp->para[0]));
22004 G__setnull(result7);
22005 return(1 || funcname || hash || result7 || libp) ;
22006}
22007
22008static int G__RootEventData_rootcint_488_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22009{
22010 ((TTofMc*) G__getstructoffset())->setPositionX((Double_t) G__double(libp->para[0]));
22011 G__setnull(result7);
22012 return(1 || funcname || hash || result7 || libp) ;
22013}
22014
22015static int G__RootEventData_rootcint_488_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22016{
22017 ((TTofMc*) G__getstructoffset())->setPositionY((Double_t) G__double(libp->para[0]));
22018 G__setnull(result7);
22019 return(1 || funcname || hash || result7 || libp) ;
22020}
22021
22022static int G__RootEventData_rootcint_488_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22023{
22024 ((TTofMc*) G__getstructoffset())->setPositionZ((Double_t) G__double(libp->para[0]));
22025 G__setnull(result7);
22026 return(1 || funcname || hash || result7 || libp) ;
22027}
22028
22029static int G__RootEventData_rootcint_488_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22030{
22031 ((TTofMc*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
22032 G__setnull(result7);
22033 return(1 || funcname || hash || result7 || libp) ;
22034}
22035
22036static int G__RootEventData_rootcint_488_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22037{
22038 ((TTofMc*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
22039 G__setnull(result7);
22040 return(1 || funcname || hash || result7 || libp) ;
22041}
22042
22043static int G__RootEventData_rootcint_488_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22044{
22045 ((TTofMc*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
22046 G__setnull(result7);
22047 return(1 || funcname || hash || result7 || libp) ;
22048}
22049
22050static int G__RootEventData_rootcint_488_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22051{
22052 ((TTofMc*) G__getstructoffset())->setTrackLength((Double_t) G__double(libp->para[0]));
22053 G__setnull(result7);
22054 return(1 || funcname || hash || result7 || libp) ;
22055}
22056
22057static int G__RootEventData_rootcint_488_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22058{
22059 ((TTofMc*) G__getstructoffset())->setFlightTime((Double_t) G__double(libp->para[0]));
22060 G__setnull(result7);
22061 return(1 || funcname || hash || result7 || libp) ;
22062}
22063
22064static int G__RootEventData_rootcint_488_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22065{
22066 G__letint(result7, 85, (long) TTofMc::Class());
22067 return(1 || funcname || hash || result7 || libp) ;
22068}
22069
22070static int G__RootEventData_rootcint_488_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22071{
22072 G__letint(result7, 67, (long) TTofMc::Class_Name());
22073 return(1 || funcname || hash || result7 || libp) ;
22074}
22075
22076static int G__RootEventData_rootcint_488_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22077{
22078 G__letint(result7, 115, (long) TTofMc::Class_Version());
22079 return(1 || funcname || hash || result7 || libp) ;
22080}
22081
22082static int G__RootEventData_rootcint_488_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22083{
22084 TTofMc::Dictionary();
22085 G__setnull(result7);
22086 return(1 || funcname || hash || result7 || libp) ;
22087}
22088
22089static int G__RootEventData_rootcint_488_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22090{
22091 ((TTofMc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
22092 G__setnull(result7);
22093 return(1 || funcname || hash || result7 || libp) ;
22094}
22095
22096static int G__RootEventData_rootcint_488_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22097{
22098 G__letint(result7, 67, (long) TTofMc::DeclFileName());
22099 return(1 || funcname || hash || result7 || libp) ;
22100}
22101
22102static int G__RootEventData_rootcint_488_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22103{
22104 G__letint(result7, 105, (long) TTofMc::ImplFileLine());
22105 return(1 || funcname || hash || result7 || libp) ;
22106}
22107
22108static int G__RootEventData_rootcint_488_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22109{
22110 G__letint(result7, 67, (long) TTofMc::ImplFileName());
22111 return(1 || funcname || hash || result7 || libp) ;
22112}
22113
22114static int G__RootEventData_rootcint_488_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22115{
22116 G__letint(result7, 105, (long) TTofMc::DeclFileLine());
22117 return(1 || funcname || hash || result7 || libp) ;
22118}
22119
22120// automatic copy constructor
22121static int G__RootEventData_rootcint_488_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22122
22123{
22124 TTofMc* p;
22125 void* tmp = (void*) G__int(libp->para[0]);
22126 p = new TTofMc(*(TTofMc*) tmp);
22127 result7->obj.i = (long) p;
22128 result7->ref = (long) p;
22129 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc));
22130 return(1 || funcname || hash || result7 || libp) ;
22131}
22132
22133// automatic destructor
22134typedef TTofMc G__TTTofMc;
22135static int G__RootEventData_rootcint_488_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22136{
22137 char* gvp = (char*) G__getgvp();
22138 long soff = G__getstructoffset();
22139 int n = G__getaryconstruct();
22140 //
22141 //has_a_delete: 1
22142 //has_own_delete1arg: 0
22143 //has_own_delete2arg: 0
22144 //
22145 if (!soff) {
22146 return(1);
22147 }
22148 if (n) {
22149 if (gvp == (char*)G__PVOID) {
22150 delete[] (TTofMc*) soff;
22151 } else {
22152 G__setgvp((long) G__PVOID);
22153 for (int i = n - 1; i >= 0; --i) {
22154 ((TTofMc*) (soff+(sizeof(TTofMc)*i)))->~G__TTTofMc();
22155 }
22156 G__setgvp((long)gvp);
22157 }
22158 } else {
22159 if (gvp == (char*)G__PVOID) {
22160 delete (TTofMc*) soff;
22161 } else {
22162 G__setgvp((long) G__PVOID);
22163 ((TTofMc*) (soff))->~G__TTTofMc();
22164 G__setgvp((long)gvp);
22165 }
22166 }
22167 G__setnull(result7);
22168 return(1 || funcname || hash || result7 || libp) ;
22169}
22170
22171// automatic assignment operator
22172static int G__RootEventData_rootcint_488_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22173{
22174 TTofMc* dest = (TTofMc*) G__getstructoffset();
22175 *dest = *(TTofMc*) libp->para[0].ref;
22176 const TTofMc& obj = *dest;
22177 result7->ref = (long) (&obj);
22178 result7->obj.i = (long) (&obj);
22179 return(1 || funcname || hash || result7 || libp) ;
22180}
22181
22182
22183/* TMucMc */
22184static int G__RootEventData_rootcint_489_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22185{
22186 TMucMc* p = NULL;
22187 char* gvp = (char*) G__getgvp();
22188 int n = G__getaryconstruct();
22189 if (n) {
22190 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
22191 p = new TMucMc[n];
22192 } else {
22193 p = new((void*) gvp) TMucMc[n];
22194 }
22195 } else {
22196 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
22197 p = new TMucMc;
22198 } else {
22199 p = new((void*) gvp) TMucMc;
22200 }
22201 }
22202 result7->obj.i = (long) p;
22203 result7->ref = (long) p;
22204 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc));
22205 return(1 || funcname || hash || result7 || libp) ;
22206}
22207
22208static int G__RootEventData_rootcint_489_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22209{
22210 G__letint(result7, 104, (long) ((const TMucMc*) G__getstructoffset())->getId());
22211 return(1 || funcname || hash || result7 || libp) ;
22212}
22213
22214static int G__RootEventData_rootcint_489_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22215{
22216 G__letint(result7, 104, (long) ((const TMucMc*) G__getstructoffset())->getTrackIndex());
22217 return(1 || funcname || hash || result7 || libp) ;
22218}
22219
22220static int G__RootEventData_rootcint_489_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22221{
22222 G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPositionX());
22223 return(1 || funcname || hash || result7 || libp) ;
22224}
22225
22226static int G__RootEventData_rootcint_489_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22227{
22228 G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPositionY());
22229 return(1 || funcname || hash || result7 || libp) ;
22230}
22231
22232static int G__RootEventData_rootcint_489_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22233{
22234 G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPositionZ());
22235 return(1 || funcname || hash || result7 || libp) ;
22236}
22237
22238static int G__RootEventData_rootcint_489_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22239{
22240 G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPx());
22241 return(1 || funcname || hash || result7 || libp) ;
22242}
22243
22244static int G__RootEventData_rootcint_489_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22245{
22246 G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPy());
22247 return(1 || funcname || hash || result7 || libp) ;
22248}
22249
22250static int G__RootEventData_rootcint_489_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22251{
22252 G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPz());
22253 return(1 || funcname || hash || result7 || libp) ;
22254}
22255
22256static int G__RootEventData_rootcint_489_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22257{
22258 ((TMucMc*) G__getstructoffset())->setId((UInt_t) G__int(libp->para[0]));
22259 G__setnull(result7);
22260 return(1 || funcname || hash || result7 || libp) ;
22261}
22262
22263static int G__RootEventData_rootcint_489_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22264{
22265 ((TMucMc*) G__getstructoffset())->setTrackIndex((UInt_t) G__int(libp->para[0]));
22266 G__setnull(result7);
22267 return(1 || funcname || hash || result7 || libp) ;
22268}
22269
22270static int G__RootEventData_rootcint_489_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22271{
22272 ((TMucMc*) G__getstructoffset())->setPositionX((Double_t) G__double(libp->para[0]));
22273 G__setnull(result7);
22274 return(1 || funcname || hash || result7 || libp) ;
22275}
22276
22277static int G__RootEventData_rootcint_489_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22278{
22279 ((TMucMc*) G__getstructoffset())->setPositionY((Double_t) G__double(libp->para[0]));
22280 G__setnull(result7);
22281 return(1 || funcname || hash || result7 || libp) ;
22282}
22283
22284static int G__RootEventData_rootcint_489_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22285{
22286 ((TMucMc*) G__getstructoffset())->setPositionZ((Double_t) G__double(libp->para[0]));
22287 G__setnull(result7);
22288 return(1 || funcname || hash || result7 || libp) ;
22289}
22290
22291static int G__RootEventData_rootcint_489_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22292{
22293 ((TMucMc*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
22294 G__setnull(result7);
22295 return(1 || funcname || hash || result7 || libp) ;
22296}
22297
22298static int G__RootEventData_rootcint_489_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22299{
22300 ((TMucMc*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
22301 G__setnull(result7);
22302 return(1 || funcname || hash || result7 || libp) ;
22303}
22304
22305static int G__RootEventData_rootcint_489_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22306{
22307 ((TMucMc*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
22308 G__setnull(result7);
22309 return(1 || funcname || hash || result7 || libp) ;
22310}
22311
22312static int G__RootEventData_rootcint_489_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22313{
22314 G__letint(result7, 85, (long) TMucMc::Class());
22315 return(1 || funcname || hash || result7 || libp) ;
22316}
22317
22318static int G__RootEventData_rootcint_489_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22319{
22320 G__letint(result7, 67, (long) TMucMc::Class_Name());
22321 return(1 || funcname || hash || result7 || libp) ;
22322}
22323
22324static int G__RootEventData_rootcint_489_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22325{
22326 G__letint(result7, 115, (long) TMucMc::Class_Version());
22327 return(1 || funcname || hash || result7 || libp) ;
22328}
22329
22330static int G__RootEventData_rootcint_489_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22331{
22332 TMucMc::Dictionary();
22333 G__setnull(result7);
22334 return(1 || funcname || hash || result7 || libp) ;
22335}
22336
22337static int G__RootEventData_rootcint_489_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22338{
22339 ((TMucMc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
22340 G__setnull(result7);
22341 return(1 || funcname || hash || result7 || libp) ;
22342}
22343
22344static int G__RootEventData_rootcint_489_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22345{
22346 G__letint(result7, 67, (long) TMucMc::DeclFileName());
22347 return(1 || funcname || hash || result7 || libp) ;
22348}
22349
22350static int G__RootEventData_rootcint_489_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22351{
22352 G__letint(result7, 105, (long) TMucMc::ImplFileLine());
22353 return(1 || funcname || hash || result7 || libp) ;
22354}
22355
22356static int G__RootEventData_rootcint_489_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22357{
22358 G__letint(result7, 67, (long) TMucMc::ImplFileName());
22359 return(1 || funcname || hash || result7 || libp) ;
22360}
22361
22362static int G__RootEventData_rootcint_489_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22363{
22364 G__letint(result7, 105, (long) TMucMc::DeclFileLine());
22365 return(1 || funcname || hash || result7 || libp) ;
22366}
22367
22368// automatic copy constructor
22369static int G__RootEventData_rootcint_489_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22370
22371{
22372 TMucMc* p;
22373 void* tmp = (void*) G__int(libp->para[0]);
22374 p = new TMucMc(*(TMucMc*) tmp);
22375 result7->obj.i = (long) p;
22376 result7->ref = (long) p;
22377 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc));
22378 return(1 || funcname || hash || result7 || libp) ;
22379}
22380
22381// automatic destructor
22382typedef TMucMc G__TTMucMc;
22383static int G__RootEventData_rootcint_489_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22384{
22385 char* gvp = (char*) G__getgvp();
22386 long soff = G__getstructoffset();
22387 int n = G__getaryconstruct();
22388 //
22389 //has_a_delete: 1
22390 //has_own_delete1arg: 0
22391 //has_own_delete2arg: 0
22392 //
22393 if (!soff) {
22394 return(1);
22395 }
22396 if (n) {
22397 if (gvp == (char*)G__PVOID) {
22398 delete[] (TMucMc*) soff;
22399 } else {
22400 G__setgvp((long) G__PVOID);
22401 for (int i = n - 1; i >= 0; --i) {
22402 ((TMucMc*) (soff+(sizeof(TMucMc)*i)))->~G__TTMucMc();
22403 }
22404 G__setgvp((long)gvp);
22405 }
22406 } else {
22407 if (gvp == (char*)G__PVOID) {
22408 delete (TMucMc*) soff;
22409 } else {
22410 G__setgvp((long) G__PVOID);
22411 ((TMucMc*) (soff))->~G__TTMucMc();
22412 G__setgvp((long)gvp);
22413 }
22414 }
22415 G__setnull(result7);
22416 return(1 || funcname || hash || result7 || libp) ;
22417}
22418
22419// automatic assignment operator
22420static int G__RootEventData_rootcint_489_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22421{
22422 TMucMc* dest = (TMucMc*) G__getstructoffset();
22423 *dest = *(TMucMc*) libp->para[0].ref;
22424 const TMucMc& obj = *dest;
22425 result7->ref = (long) (&obj);
22426 result7->obj.i = (long) (&obj);
22427 return(1 || funcname || hash || result7 || libp) ;
22428}
22429
22430
22431/* TMcParticle */
22432static int G__RootEventData_rootcint_490_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22433{
22434 TMcParticle* p = NULL;
22435 char* gvp = (char*) G__getgvp();
22436 int n = G__getaryconstruct();
22437 if (n) {
22438 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
22439 p = new TMcParticle[n];
22440 } else {
22441 p = new((void*) gvp) TMcParticle[n];
22442 }
22443 } else {
22444 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
22445 p = new TMcParticle;
22446 } else {
22447 p = new((void*) gvp) TMcParticle;
22448 }
22449 }
22450 result7->obj.i = (long) p;
22451 result7->ref = (long) p;
22452 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle));
22453 return(1 || funcname || hash || result7 || libp) ;
22454}
22455
22456static int G__RootEventData_rootcint_490_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22457{
22458 G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getParticleID());
22459 return(1 || funcname || hash || result7 || libp) ;
22460}
22461
22462static int G__RootEventData_rootcint_490_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22463{
22464 G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getTrackIndex());
22465 return(1 || funcname || hash || result7 || libp) ;
22466}
22467
22468static int G__RootEventData_rootcint_490_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22469{
22470 G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getVertexIndex0());
22471 return(1 || funcname || hash || result7 || libp) ;
22472}
22473
22474static int G__RootEventData_rootcint_490_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22475{
22476 G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getVertexIndex1());
22477 return(1 || funcname || hash || result7 || libp) ;
22478}
22479
22480static int G__RootEventData_rootcint_490_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22481{
22482 G__letint(result7, 104, (long) ((const TMcParticle*) G__getstructoffset())->getStatusFlags());
22483 return(1 || funcname || hash || result7 || libp) ;
22484}
22485
22486static int G__RootEventData_rootcint_490_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22487{
22488 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialPositionX());
22489 return(1 || funcname || hash || result7 || libp) ;
22490}
22491
22492static int G__RootEventData_rootcint_490_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22493{
22494 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialPositionY());
22495 return(1 || funcname || hash || result7 || libp) ;
22496}
22497
22498static int G__RootEventData_rootcint_490_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22499{
22500 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialPositionZ());
22501 return(1 || funcname || hash || result7 || libp) ;
22502}
22503
22504static int G__RootEventData_rootcint_490_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22505{
22506 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialPositionT());
22507 return(1 || funcname || hash || result7 || libp) ;
22508}
22509
22510static int G__RootEventData_rootcint_490_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22511{
22512 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getFinalPositionX());
22513 return(1 || funcname || hash || result7 || libp) ;
22514}
22515
22516static int G__RootEventData_rootcint_490_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22517{
22518 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getFinalPositionY());
22519 return(1 || funcname || hash || result7 || libp) ;
22520}
22521
22522static int G__RootEventData_rootcint_490_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22523{
22524 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getFinalPositionZ());
22525 return(1 || funcname || hash || result7 || libp) ;
22526}
22527
22528static int G__RootEventData_rootcint_490_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22529{
22530 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getFinalPositionT());
22531 return(1 || funcname || hash || result7 || libp) ;
22532}
22533
22534static int G__RootEventData_rootcint_490_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22535{
22536 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialMomentumX());
22537 return(1 || funcname || hash || result7 || libp) ;
22538}
22539
22540static int G__RootEventData_rootcint_490_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22541{
22542 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialMomentumY());
22543 return(1 || funcname || hash || result7 || libp) ;
22544}
22545
22546static int G__RootEventData_rootcint_490_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22547{
22548 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialMomentumZ());
22549 return(1 || funcname || hash || result7 || libp) ;
22550}
22551
22552static int G__RootEventData_rootcint_490_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22553{
22554 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialMomentumE());
22555 return(1 || funcname || hash || result7 || libp) ;
22556}
22557
22558static int G__RootEventData_rootcint_490_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22559{
22560 G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getMother());
22561 return(1 || funcname || hash || result7 || libp) ;
22562}
22563
22564static int G__RootEventData_rootcint_490_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22565{
22566 {
22567 const vector<Int_t>* pobj;
22568 const vector<Int_t> xobj = ((const TMcParticle*) G__getstructoffset())->getDaughters();
22569 pobj = new vector<Int_t>(xobj);
22570 result7->obj.i = (long) ((void*) pobj);
22571 result7->ref = result7->obj.i;
22572 G__store_tempobject(*result7);
22573 }
22574 return(1 || funcname || hash || result7 || libp) ;
22575}
22576
22577static int G__RootEventData_rootcint_490_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22578{
22579 G__letint(result7, 103, (long) ((const TMcParticle*) G__getstructoffset())->primaryParticle());
22580 return(1 || funcname || hash || result7 || libp) ;
22581}
22582
22583static int G__RootEventData_rootcint_490_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22584{
22585 G__letint(result7, 103, (long) ((const TMcParticle*) G__getstructoffset())->leafParticle());
22586 return(1 || funcname || hash || result7 || libp) ;
22587}
22588
22589static int G__RootEventData_rootcint_490_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22590{
22591 G__letint(result7, 103, (long) ((const TMcParticle*) G__getstructoffset())->decayFromGenerator());
22592 return(1 || funcname || hash || result7 || libp) ;
22593}
22594
22595static int G__RootEventData_rootcint_490_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22596{
22597 G__letint(result7, 103, (long) ((const TMcParticle*) G__getstructoffset())->decayInFlight());
22598 return(1 || funcname || hash || result7 || libp) ;
22599}
22600
22601static int G__RootEventData_rootcint_490_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22602{
22603 ((TMcParticle*) G__getstructoffset())->setParticleID((Int_t) G__int(libp->para[0]));
22604 G__setnull(result7);
22605 return(1 || funcname || hash || result7 || libp) ;
22606}
22607
22608static int G__RootEventData_rootcint_490_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22609{
22610 ((TMcParticle*) G__getstructoffset())->setTrackIndex((Int_t) G__int(libp->para[0]));
22611 G__setnull(result7);
22612 return(1 || funcname || hash || result7 || libp) ;
22613}
22614
22615static int G__RootEventData_rootcint_490_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22616{
22617 ((TMcParticle*) G__getstructoffset())->setVertexIndex0((Int_t) G__int(libp->para[0]));
22618 G__setnull(result7);
22619 return(1 || funcname || hash || result7 || libp) ;
22620}
22621
22622static int G__RootEventData_rootcint_490_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22623{
22624 ((TMcParticle*) G__getstructoffset())->setVertexIndex1((Int_t) G__int(libp->para[0]));
22625 G__setnull(result7);
22626 return(1 || funcname || hash || result7 || libp) ;
22627}
22628
22629static int G__RootEventData_rootcint_490_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22630{
22631 ((TMcParticle*) G__getstructoffset())->setStatusFlags((UInt_t) G__int(libp->para[0]));
22632 G__setnull(result7);
22633 return(1 || funcname || hash || result7 || libp) ;
22634}
22635
22636static int G__RootEventData_rootcint_490_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22637{
22638 ((TMcParticle*) G__getstructoffset())->setInitialPositionX((Double_t) G__double(libp->para[0]));
22639 G__setnull(result7);
22640 return(1 || funcname || hash || result7 || libp) ;
22641}
22642
22643static int G__RootEventData_rootcint_490_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22644{
22645 ((TMcParticle*) G__getstructoffset())->setInitialPositionY((Double_t) G__double(libp->para[0]));
22646 G__setnull(result7);
22647 return(1 || funcname || hash || result7 || libp) ;
22648}
22649
22650static int G__RootEventData_rootcint_490_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22651{
22652 ((TMcParticle*) G__getstructoffset())->setInitialPositionZ((Double_t) G__double(libp->para[0]));
22653 G__setnull(result7);
22654 return(1 || funcname || hash || result7 || libp) ;
22655}
22656
22657static int G__RootEventData_rootcint_490_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22658{
22659 ((TMcParticle*) G__getstructoffset())->setInitialPositionT((Double_t) G__double(libp->para[0]));
22660 G__setnull(result7);
22661 return(1 || funcname || hash || result7 || libp) ;
22662}
22663
22664static int G__RootEventData_rootcint_490_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22665{
22666 ((TMcParticle*) G__getstructoffset())->setFinalPositionX((Double_t) G__double(libp->para[0]));
22667 G__setnull(result7);
22668 return(1 || funcname || hash || result7 || libp) ;
22669}
22670
22671static int G__RootEventData_rootcint_490_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22672{
22673 ((TMcParticle*) G__getstructoffset())->setFinalPositionY((Double_t) G__double(libp->para[0]));
22674 G__setnull(result7);
22675 return(1 || funcname || hash || result7 || libp) ;
22676}
22677
22678static int G__RootEventData_rootcint_490_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22679{
22680 ((TMcParticle*) G__getstructoffset())->setFinalPositionZ((Double_t) G__double(libp->para[0]));
22681 G__setnull(result7);
22682 return(1 || funcname || hash || result7 || libp) ;
22683}
22684
22685static int G__RootEventData_rootcint_490_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22686{
22687 ((TMcParticle*) G__getstructoffset())->setFinalPositionT((Double_t) G__double(libp->para[0]));
22688 G__setnull(result7);
22689 return(1 || funcname || hash || result7 || libp) ;
22690}
22691
22692static int G__RootEventData_rootcint_490_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22693{
22694 ((TMcParticle*) G__getstructoffset())->setInitialMomentumX((Double_t) G__double(libp->para[0]));
22695 G__setnull(result7);
22696 return(1 || funcname || hash || result7 || libp) ;
22697}
22698
22699static int G__RootEventData_rootcint_490_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22700{
22701 ((TMcParticle*) G__getstructoffset())->setInitialMomentumY((Double_t) G__double(libp->para[0]));
22702 G__setnull(result7);
22703 return(1 || funcname || hash || result7 || libp) ;
22704}
22705
22706static int G__RootEventData_rootcint_490_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22707{
22708 ((TMcParticle*) G__getstructoffset())->setInitialMomentumZ((Double_t) G__double(libp->para[0]));
22709 G__setnull(result7);
22710 return(1 || funcname || hash || result7 || libp) ;
22711}
22712
22713static int G__RootEventData_rootcint_490_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22714{
22715 ((TMcParticle*) G__getstructoffset())->setInitialMomentumE((Double_t) G__double(libp->para[0]));
22716 G__setnull(result7);
22717 return(1 || funcname || hash || result7 || libp) ;
22718}
22719
22720static int G__RootEventData_rootcint_490_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22721{
22722 ((TMcParticle*) G__getstructoffset())->setMother((Int_t) G__int(libp->para[0]));
22723 G__setnull(result7);
22724 return(1 || funcname || hash || result7 || libp) ;
22725}
22726
22727static int G__RootEventData_rootcint_490_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22728{
22729 ((TMcParticle*) G__getstructoffset())->setDaughters(*(vector<Int_t>*) libp->para[0].ref);
22730 G__setnull(result7);
22731 return(1 || funcname || hash || result7 || libp) ;
22732}
22733
22734static int G__RootEventData_rootcint_490_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22735{
22736 G__letint(result7, 85, (long) TMcParticle::Class());
22737 return(1 || funcname || hash || result7 || libp) ;
22738}
22739
22740static int G__RootEventData_rootcint_490_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22741{
22742 G__letint(result7, 67, (long) TMcParticle::Class_Name());
22743 return(1 || funcname || hash || result7 || libp) ;
22744}
22745
22746static int G__RootEventData_rootcint_490_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22747{
22748 G__letint(result7, 115, (long) TMcParticle::Class_Version());
22749 return(1 || funcname || hash || result7 || libp) ;
22750}
22751
22752static int G__RootEventData_rootcint_490_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22753{
22754 TMcParticle::Dictionary();
22755 G__setnull(result7);
22756 return(1 || funcname || hash || result7 || libp) ;
22757}
22758
22759static int G__RootEventData_rootcint_490_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22760{
22761 ((TMcParticle*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
22762 G__setnull(result7);
22763 return(1 || funcname || hash || result7 || libp) ;
22764}
22765
22766static int G__RootEventData_rootcint_490_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22767{
22768 G__letint(result7, 67, (long) TMcParticle::DeclFileName());
22769 return(1 || funcname || hash || result7 || libp) ;
22770}
22771
22772static int G__RootEventData_rootcint_490_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22773{
22774 G__letint(result7, 105, (long) TMcParticle::ImplFileLine());
22775 return(1 || funcname || hash || result7 || libp) ;
22776}
22777
22778static int G__RootEventData_rootcint_490_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22779{
22780 G__letint(result7, 67, (long) TMcParticle::ImplFileName());
22781 return(1 || funcname || hash || result7 || libp) ;
22782}
22783
22784static int G__RootEventData_rootcint_490_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22785{
22786 G__letint(result7, 105, (long) TMcParticle::DeclFileLine());
22787 return(1 || funcname || hash || result7 || libp) ;
22788}
22789
22790// automatic copy constructor
22791static int G__RootEventData_rootcint_490_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22792
22793{
22794 TMcParticle* p;
22795 void* tmp = (void*) G__int(libp->para[0]);
22796 p = new TMcParticle(*(TMcParticle*) tmp);
22797 result7->obj.i = (long) p;
22798 result7->ref = (long) p;
22799 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle));
22800 return(1 || funcname || hash || result7 || libp) ;
22801}
22802
22803// automatic destructor
22804typedef TMcParticle G__TTMcParticle;
22805static int G__RootEventData_rootcint_490_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22806{
22807 char* gvp = (char*) G__getgvp();
22808 long soff = G__getstructoffset();
22809 int n = G__getaryconstruct();
22810 //
22811 //has_a_delete: 1
22812 //has_own_delete1arg: 0
22813 //has_own_delete2arg: 0
22814 //
22815 if (!soff) {
22816 return(1);
22817 }
22818 if (n) {
22819 if (gvp == (char*)G__PVOID) {
22820 delete[] (TMcParticle*) soff;
22821 } else {
22822 G__setgvp((long) G__PVOID);
22823 for (int i = n - 1; i >= 0; --i) {
22824 ((TMcParticle*) (soff+(sizeof(TMcParticle)*i)))->~G__TTMcParticle();
22825 }
22826 G__setgvp((long)gvp);
22827 }
22828 } else {
22829 if (gvp == (char*)G__PVOID) {
22830 delete (TMcParticle*) soff;
22831 } else {
22832 G__setgvp((long) G__PVOID);
22833 ((TMcParticle*) (soff))->~G__TTMcParticle();
22834 G__setgvp((long)gvp);
22835 }
22836 }
22837 G__setnull(result7);
22838 return(1 || funcname || hash || result7 || libp) ;
22839}
22840
22841// automatic assignment operator
22842static int G__RootEventData_rootcint_490_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22843{
22844 TMcParticle* dest = (TMcParticle*) G__getstructoffset();
22845 *dest = *(TMcParticle*) libp->para[0].ref;
22846 const TMcParticle& obj = *dest;
22847 result7->ref = (long) (&obj);
22848 result7->obj.i = (long) (&obj);
22849 return(1 || funcname || hash || result7 || libp) ;
22850}
22851
22852
22853/* TMcEvent */
22854static int G__RootEventData_rootcint_492_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22855{
22856 TMcEvent* p = NULL;
22857 char* gvp = (char*) G__getgvp();
22858 int n = G__getaryconstruct();
22859 if (n) {
22860 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
22861 p = new TMcEvent[n];
22862 } else {
22863 p = new((void*) gvp) TMcEvent[n];
22864 }
22865 } else {
22866 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
22867 p = new TMcEvent;
22868 } else {
22869 p = new((void*) gvp) TMcEvent;
22870 }
22871 }
22872 result7->obj.i = (long) p;
22873 result7->ref = (long) p;
22874 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent));
22875 return(1 || funcname || hash || result7 || libp) ;
22876}
22877
22878static int G__RootEventData_rootcint_492_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22879{
22880 ((TMcEvent*) G__getstructoffset())->initialize();
22881 G__setnull(result7);
22882 return(1 || funcname || hash || result7 || libp) ;
22883}
22884
22885static int G__RootEventData_rootcint_492_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22886{
22887 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMdcMcHitCol());
22888 return(1 || funcname || hash || result7 || libp) ;
22889}
22890
22891static int G__RootEventData_rootcint_492_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22892{
22893 ((TMcEvent*) G__getstructoffset())->addMdcMc((TMdcMc*) G__int(libp->para[0]));
22894 G__setnull(result7);
22895 return(1 || funcname || hash || result7 || libp) ;
22896}
22897
22898static int G__RootEventData_rootcint_492_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22899{
22900 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMdcMc((Int_t) G__int(libp->para[0])));
22901 return(1 || funcname || hash || result7 || libp) ;
22902}
22903
22904static int G__RootEventData_rootcint_492_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22905{
22906 ((TMcEvent*) G__getstructoffset())->clearMdcMcHitCol();
22907 G__setnull(result7);
22908 return(1 || funcname || hash || result7 || libp) ;
22909}
22910
22911static int G__RootEventData_rootcint_492_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22912{
22913 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getEmcMcHitCol());
22914 return(1 || funcname || hash || result7 || libp) ;
22915}
22916
22917static int G__RootEventData_rootcint_492_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22918{
22919 ((TMcEvent*) G__getstructoffset())->addEmcMc((TEmcMc*) G__int(libp->para[0]));
22920 G__setnull(result7);
22921 return(1 || funcname || hash || result7 || libp) ;
22922}
22923
22924static int G__RootEventData_rootcint_492_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22925{
22926 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getEmcMc((Int_t) G__int(libp->para[0])));
22927 return(1 || funcname || hash || result7 || libp) ;
22928}
22929
22930static int G__RootEventData_rootcint_492_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22931{
22932 ((TMcEvent*) G__getstructoffset())->clearEmcMcHitCol();
22933 G__setnull(result7);
22934 return(1 || funcname || hash || result7 || libp) ;
22935}
22936
22937static int G__RootEventData_rootcint_492_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22938{
22939 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getTofMcHitCol());
22940 return(1 || funcname || hash || result7 || libp) ;
22941}
22942
22943static int G__RootEventData_rootcint_492_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22944{
22945 ((TMcEvent*) G__getstructoffset())->addTofMc((TTofMc*) G__int(libp->para[0]));
22946 G__setnull(result7);
22947 return(1 || funcname || hash || result7 || libp) ;
22948}
22949
22950static int G__RootEventData_rootcint_492_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22951{
22952 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getTofMc((Int_t) G__int(libp->para[0])));
22953 return(1 || funcname || hash || result7 || libp) ;
22954}
22955
22956static int G__RootEventData_rootcint_492_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22957{
22958 ((TMcEvent*) G__getstructoffset())->clearTofMcHitCol();
22959 G__setnull(result7);
22960 return(1 || funcname || hash || result7 || libp) ;
22961}
22962
22963static int G__RootEventData_rootcint_492_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22964{
22965 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMucMcHitCol());
22966 return(1 || funcname || hash || result7 || libp) ;
22967}
22968
22969static int G__RootEventData_rootcint_492_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22970{
22971 ((TMcEvent*) G__getstructoffset())->addMucMc((TMucMc*) G__int(libp->para[0]));
22972 G__setnull(result7);
22973 return(1 || funcname || hash || result7 || libp) ;
22974}
22975
22976static int G__RootEventData_rootcint_492_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22977{
22978 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMucMc((Int_t) G__int(libp->para[0])));
22979 return(1 || funcname || hash || result7 || libp) ;
22980}
22981
22982static int G__RootEventData_rootcint_492_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22983{
22984 ((TMcEvent*) G__getstructoffset())->clearMucMcHitCol();
22985 G__setnull(result7);
22986 return(1 || funcname || hash || result7 || libp) ;
22987}
22988
22989static int G__RootEventData_rootcint_492_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22990{
22991 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMcParticleCol());
22992 return(1 || funcname || hash || result7 || libp) ;
22993}
22994
22995static int G__RootEventData_rootcint_492_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22996{
22997 ((TMcEvent*) G__getstructoffset())->addMcParticle((TMcParticle*) G__int(libp->para[0]));
22998 G__setnull(result7);
22999 return(1 || funcname || hash || result7 || libp) ;
23000}
23001
23002static int G__RootEventData_rootcint_492_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23003{
23004 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMcParticle((Int_t) G__int(libp->para[0])));
23005 return(1 || funcname || hash || result7 || libp) ;
23006}
23007
23008static int G__RootEventData_rootcint_492_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23009{
23010 ((TMcEvent*) G__getstructoffset())->clearMcParticleCol();
23011 G__setnull(result7);
23012 return(1 || funcname || hash || result7 || libp) ;
23013}
23014
23015static int G__RootEventData_rootcint_492_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23016{
23017 G__letint(result7, 85, (long) TMcEvent::Class());
23018 return(1 || funcname || hash || result7 || libp) ;
23019}
23020
23021static int G__RootEventData_rootcint_492_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23022{
23023 G__letint(result7, 67, (long) TMcEvent::Class_Name());
23024 return(1 || funcname || hash || result7 || libp) ;
23025}
23026
23027static int G__RootEventData_rootcint_492_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23028{
23029 G__letint(result7, 115, (long) TMcEvent::Class_Version());
23030 return(1 || funcname || hash || result7 || libp) ;
23031}
23032
23033static int G__RootEventData_rootcint_492_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23034{
23035 TMcEvent::Dictionary();
23036 G__setnull(result7);
23037 return(1 || funcname || hash || result7 || libp) ;
23038}
23039
23040static int G__RootEventData_rootcint_492_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23041{
23042 ((TMcEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
23043 G__setnull(result7);
23044 return(1 || funcname || hash || result7 || libp) ;
23045}
23046
23047static int G__RootEventData_rootcint_492_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23048{
23049 G__letint(result7, 67, (long) TMcEvent::DeclFileName());
23050 return(1 || funcname || hash || result7 || libp) ;
23051}
23052
23053static int G__RootEventData_rootcint_492_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23054{
23055 G__letint(result7, 105, (long) TMcEvent::ImplFileLine());
23056 return(1 || funcname || hash || result7 || libp) ;
23057}
23058
23059static int G__RootEventData_rootcint_492_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23060{
23061 G__letint(result7, 67, (long) TMcEvent::ImplFileName());
23062 return(1 || funcname || hash || result7 || libp) ;
23063}
23064
23065static int G__RootEventData_rootcint_492_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23066{
23067 G__letint(result7, 105, (long) TMcEvent::DeclFileLine());
23068 return(1 || funcname || hash || result7 || libp) ;
23069}
23070
23071// automatic copy constructor
23072static int G__RootEventData_rootcint_492_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23073
23074{
23075 TMcEvent* p;
23076 void* tmp = (void*) G__int(libp->para[0]);
23077 p = new TMcEvent(*(TMcEvent*) tmp);
23078 result7->obj.i = (long) p;
23079 result7->ref = (long) p;
23080 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent));
23081 return(1 || funcname || hash || result7 || libp) ;
23082}
23083
23084// automatic destructor
23085typedef TMcEvent G__TTMcEvent;
23086static int G__RootEventData_rootcint_492_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23087{
23088 char* gvp = (char*) G__getgvp();
23089 long soff = G__getstructoffset();
23090 int n = G__getaryconstruct();
23091 //
23092 //has_a_delete: 1
23093 //has_own_delete1arg: 0
23094 //has_own_delete2arg: 0
23095 //
23096 if (!soff) {
23097 return(1);
23098 }
23099 if (n) {
23100 if (gvp == (char*)G__PVOID) {
23101 delete[] (TMcEvent*) soff;
23102 } else {
23103 G__setgvp((long) G__PVOID);
23104 for (int i = n - 1; i >= 0; --i) {
23105 ((TMcEvent*) (soff+(sizeof(TMcEvent)*i)))->~G__TTMcEvent();
23106 }
23107 G__setgvp((long)gvp);
23108 }
23109 } else {
23110 if (gvp == (char*)G__PVOID) {
23111 delete (TMcEvent*) soff;
23112 } else {
23113 G__setgvp((long) G__PVOID);
23114 ((TMcEvent*) (soff))->~G__TTMcEvent();
23115 G__setgvp((long)gvp);
23116 }
23117 }
23118 G__setnull(result7);
23119 return(1 || funcname || hash || result7 || libp) ;
23120}
23121
23122// automatic assignment operator
23123static int G__RootEventData_rootcint_492_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23124{
23125 TMcEvent* dest = (TMcEvent*) G__getstructoffset();
23126 *dest = *(TMcEvent*) libp->para[0].ref;
23127 const TMcEvent& obj = *dest;
23128 result7->ref = (long) (&obj);
23129 result7->obj.i = (long) (&obj);
23130 return(1 || funcname || hash || result7 || libp) ;
23131}
23132
23133
23134/* TEvtHeader */
23135static int G__RootEventData_rootcint_493_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23136{
23137 TEvtHeader* p = NULL;
23138 char* gvp = (char*) G__getgvp();
23139 int n = G__getaryconstruct();
23140 if (n) {
23141 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23142 p = new TEvtHeader[n];
23143 } else {
23144 p = new((void*) gvp) TEvtHeader[n];
23145 }
23146 } else {
23147 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23148 p = new TEvtHeader;
23149 } else {
23150 p = new((void*) gvp) TEvtHeader;
23151 }
23152 }
23153 result7->obj.i = (long) p;
23154 result7->ref = (long) p;
23155 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader));
23156 return(1 || funcname || hash || result7 || libp) ;
23157}
23158
23159static int G__RootEventData_rootcint_493_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23160{
23161 ((TEvtHeader*) G__getstructoffset())->initialize((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
23162, (UInt_t) G__int(libp->para[2]));
23163 G__setnull(result7);
23164 return(1 || funcname || hash || result7 || libp) ;
23165}
23166
23167static int G__RootEventData_rootcint_493_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23168{
23169 G__letint(result7, 105, (long) ((TEvtHeader*) G__getstructoffset())->getEventId());
23170 return(1 || funcname || hash || result7 || libp) ;
23171}
23172
23173static int G__RootEventData_rootcint_493_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23174{
23175 G__letint(result7, 105, (long) ((TEvtHeader*) G__getstructoffset())->getRunId());
23176 return(1 || funcname || hash || result7 || libp) ;
23177}
23178
23179static int G__RootEventData_rootcint_493_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23180{
23181 G__letint(result7, 104, (long) ((const TEvtHeader*) G__getstructoffset())->time());
23182 return(1 || funcname || hash || result7 || libp) ;
23183}
23184
23185static int G__RootEventData_rootcint_493_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23186{
23187 ((TEvtHeader*) G__getstructoffset())->setTime((int) G__int(libp->para[0]));
23188 G__setnull(result7);
23189 return(1 || funcname || hash || result7 || libp) ;
23190}
23191
23192static int G__RootEventData_rootcint_493_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23193{
23194 G__letint(result7, 104, (long) ((TEvtHeader*) G__getstructoffset())->getEventTag());
23195 return(1 || funcname || hash || result7 || libp) ;
23196}
23197
23198static int G__RootEventData_rootcint_493_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23199{
23200 ((TEvtHeader*) G__getstructoffset())->setFlag1((int) G__int(libp->para[0]));
23201 G__setnull(result7);
23202 return(1 || funcname || hash || result7 || libp) ;
23203}
23204
23205static int G__RootEventData_rootcint_493_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23206{
23207 ((TEvtHeader*) G__getstructoffset())->setFlag2((int) G__int(libp->para[0]));
23208 G__setnull(result7);
23209 return(1 || funcname || hash || result7 || libp) ;
23210}
23211
23212static int G__RootEventData_rootcint_493_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23213{
23214 G__letint(result7, 104, (long) ((TEvtHeader*) G__getstructoffset())->getFlag1());
23215 return(1 || funcname || hash || result7 || libp) ;
23216}
23217
23218static int G__RootEventData_rootcint_493_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23219{
23220 G__letint(result7, 104, (long) ((TEvtHeader*) G__getstructoffset())->getFlag2());
23221 return(1 || funcname || hash || result7 || libp) ;
23222}
23223
23224static int G__RootEventData_rootcint_493_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23225{
23226 ((TEvtHeader*) G__getstructoffset())->setEtsT1((unsigned long) G__int(libp->para[0]));
23227 G__setnull(result7);
23228 return(1 || funcname || hash || result7 || libp) ;
23229}
23230
23231static int G__RootEventData_rootcint_493_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23232{
23233 ((TEvtHeader*) G__getstructoffset())->setEtsT2((unsigned long) G__int(libp->para[0]));
23234 G__setnull(result7);
23235 return(1 || funcname || hash || result7 || libp) ;
23236}
23237
23238static int G__RootEventData_rootcint_493_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23239{
23240 G__letint(result7, 107, (long) ((TEvtHeader*) G__getstructoffset())->getEtsT1());
23241 return(1 || funcname || hash || result7 || libp) ;
23242}
23243
23244static int G__RootEventData_rootcint_493_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23245{
23246 G__letint(result7, 107, (long) ((TEvtHeader*) G__getstructoffset())->getEtsT2());
23247 return(1 || funcname || hash || result7 || libp) ;
23248}
23249
23250static int G__RootEventData_rootcint_493_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23251{
23252 G__letint(result7, 85, (long) TEvtHeader::Class());
23253 return(1 || funcname || hash || result7 || libp) ;
23254}
23255
23256static int G__RootEventData_rootcint_493_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23257{
23258 G__letint(result7, 67, (long) TEvtHeader::Class_Name());
23259 return(1 || funcname || hash || result7 || libp) ;
23260}
23261
23262static int G__RootEventData_rootcint_493_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23263{
23264 G__letint(result7, 115, (long) TEvtHeader::Class_Version());
23265 return(1 || funcname || hash || result7 || libp) ;
23266}
23267
23268static int G__RootEventData_rootcint_493_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23269{
23270 TEvtHeader::Dictionary();
23271 G__setnull(result7);
23272 return(1 || funcname || hash || result7 || libp) ;
23273}
23274
23275static int G__RootEventData_rootcint_493_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23276{
23277 ((TEvtHeader*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
23278 G__setnull(result7);
23279 return(1 || funcname || hash || result7 || libp) ;
23280}
23281
23282static int G__RootEventData_rootcint_493_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23283{
23284 G__letint(result7, 67, (long) TEvtHeader::DeclFileName());
23285 return(1 || funcname || hash || result7 || libp) ;
23286}
23287
23288static int G__RootEventData_rootcint_493_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23289{
23290 G__letint(result7, 105, (long) TEvtHeader::ImplFileLine());
23291 return(1 || funcname || hash || result7 || libp) ;
23292}
23293
23294static int G__RootEventData_rootcint_493_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23295{
23296 G__letint(result7, 67, (long) TEvtHeader::ImplFileName());
23297 return(1 || funcname || hash || result7 || libp) ;
23298}
23299
23300static int G__RootEventData_rootcint_493_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23301{
23302 G__letint(result7, 105, (long) TEvtHeader::DeclFileLine());
23303 return(1 || funcname || hash || result7 || libp) ;
23304}
23305
23306// automatic copy constructor
23307static int G__RootEventData_rootcint_493_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23308
23309{
23310 TEvtHeader* p;
23311 void* tmp = (void*) G__int(libp->para[0]);
23312 p = new TEvtHeader(*(TEvtHeader*) tmp);
23313 result7->obj.i = (long) p;
23314 result7->ref = (long) p;
23315 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader));
23316 return(1 || funcname || hash || result7 || libp) ;
23317}
23318
23319// automatic destructor
23320typedef TEvtHeader G__TTEvtHeader;
23321static int G__RootEventData_rootcint_493_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23322{
23323 char* gvp = (char*) G__getgvp();
23324 long soff = G__getstructoffset();
23325 int n = G__getaryconstruct();
23326 //
23327 //has_a_delete: 1
23328 //has_own_delete1arg: 0
23329 //has_own_delete2arg: 0
23330 //
23331 if (!soff) {
23332 return(1);
23333 }
23334 if (n) {
23335 if (gvp == (char*)G__PVOID) {
23336 delete[] (TEvtHeader*) soff;
23337 } else {
23338 G__setgvp((long) G__PVOID);
23339 for (int i = n - 1; i >= 0; --i) {
23340 ((TEvtHeader*) (soff+(sizeof(TEvtHeader)*i)))->~G__TTEvtHeader();
23341 }
23342 G__setgvp((long)gvp);
23343 }
23344 } else {
23345 if (gvp == (char*)G__PVOID) {
23346 delete (TEvtHeader*) soff;
23347 } else {
23348 G__setgvp((long) G__PVOID);
23349 ((TEvtHeader*) (soff))->~G__TTEvtHeader();
23350 G__setgvp((long)gvp);
23351 }
23352 }
23353 G__setnull(result7);
23354 return(1 || funcname || hash || result7 || libp) ;
23355}
23356
23357// automatic assignment operator
23358static int G__RootEventData_rootcint_493_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23359{
23360 TEvtHeader* dest = (TEvtHeader*) G__getstructoffset();
23361 *dest = *(TEvtHeader*) libp->para[0].ref;
23362 const TEvtHeader& obj = *dest;
23363 result7->ref = (long) (&obj);
23364 result7->obj.i = (long) (&obj);
23365 return(1 || funcname || hash || result7 || libp) ;
23366}
23367
23368
23369/* TEvtNavigator */
23370static int G__RootEventData_rootcint_503_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23371{
23372 TEvtNavigator* p = NULL;
23373 char* gvp = (char*) G__getgvp();
23374 int n = G__getaryconstruct();
23375 if (n) {
23376 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23377 p = new TEvtNavigator[n];
23378 } else {
23379 p = new((void*) gvp) TEvtNavigator[n];
23380 }
23381 } else {
23382 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23383 p = new TEvtNavigator;
23384 } else {
23385 p = new((void*) gvp) TEvtNavigator;
23386 }
23387 }
23388 result7->obj.i = (long) p;
23389 result7->ref = (long) p;
23390 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator));
23391 return(1 || funcname || hash || result7 || libp) ;
23392}
23393
23394static int G__RootEventData_rootcint_503_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23395{
23396 ((TEvtNavigator*) G__getstructoffset())->LoadMcMdcMcHits(*(multimap<int,int>*) libp->para[0].ref);
23397 G__setnull(result7);
23398 return(1 || funcname || hash || result7 || libp) ;
23399}
23400
23401static int G__RootEventData_rootcint_503_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23402{
23403 ((TEvtNavigator*) G__getstructoffset())->LoadMcMdcTracks(*(multimap<int,int>*) libp->para[0].ref);
23404 G__setnull(result7);
23405 return(1 || funcname || hash || result7 || libp) ;
23406}
23407
23408static int G__RootEventData_rootcint_503_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23409{
23410 ((TEvtNavigator*) G__getstructoffset())->LoadMcEmcMcHits(*(multimap<int,int>*) libp->para[0].ref);
23411 G__setnull(result7);
23412 return(1 || funcname || hash || result7 || libp) ;
23413}
23414
23415static int G__RootEventData_rootcint_503_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23416{
23417 ((TEvtNavigator*) G__getstructoffset())->LoadMcEmcRecShowers(*(multimap<int,int>*) libp->para[0].ref);
23418 G__setnull(result7);
23419 return(1 || funcname || hash || result7 || libp) ;
23420}
23421
23422static int G__RootEventData_rootcint_503_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23423{
23424 G__letint(result7, 85, (long) TEvtNavigator::Class());
23425 return(1 || funcname || hash || result7 || libp) ;
23426}
23427
23428static int G__RootEventData_rootcint_503_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23429{
23430 G__letint(result7, 67, (long) TEvtNavigator::Class_Name());
23431 return(1 || funcname || hash || result7 || libp) ;
23432}
23433
23434static int G__RootEventData_rootcint_503_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23435{
23436 G__letint(result7, 115, (long) TEvtNavigator::Class_Version());
23437 return(1 || funcname || hash || result7 || libp) ;
23438}
23439
23440static int G__RootEventData_rootcint_503_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23441{
23442 TEvtNavigator::Dictionary();
23443 G__setnull(result7);
23444 return(1 || funcname || hash || result7 || libp) ;
23445}
23446
23447static int G__RootEventData_rootcint_503_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23448{
23449 ((TEvtNavigator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
23450 G__setnull(result7);
23451 return(1 || funcname || hash || result7 || libp) ;
23452}
23453
23454static int G__RootEventData_rootcint_503_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23455{
23456 G__letint(result7, 67, (long) TEvtNavigator::DeclFileName());
23457 return(1 || funcname || hash || result7 || libp) ;
23458}
23459
23460static int G__RootEventData_rootcint_503_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23461{
23462 G__letint(result7, 105, (long) TEvtNavigator::ImplFileLine());
23463 return(1 || funcname || hash || result7 || libp) ;
23464}
23465
23466static int G__RootEventData_rootcint_503_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23467{
23468 G__letint(result7, 67, (long) TEvtNavigator::ImplFileName());
23469 return(1 || funcname || hash || result7 || libp) ;
23470}
23471
23472static int G__RootEventData_rootcint_503_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23473{
23474 G__letint(result7, 105, (long) TEvtNavigator::DeclFileLine());
23475 return(1 || funcname || hash || result7 || libp) ;
23476}
23477
23478// automatic copy constructor
23479static int G__RootEventData_rootcint_503_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23480
23481{
23482 TEvtNavigator* p;
23483 void* tmp = (void*) G__int(libp->para[0]);
23484 p = new TEvtNavigator(*(TEvtNavigator*) tmp);
23485 result7->obj.i = (long) p;
23486 result7->ref = (long) p;
23487 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator));
23488 return(1 || funcname || hash || result7 || libp) ;
23489}
23490
23491// automatic destructor
23492typedef TEvtNavigator G__TTEvtNavigator;
23493static int G__RootEventData_rootcint_503_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23494{
23495 char* gvp = (char*) G__getgvp();
23496 long soff = G__getstructoffset();
23497 int n = G__getaryconstruct();
23498 //
23499 //has_a_delete: 1
23500 //has_own_delete1arg: 0
23501 //has_own_delete2arg: 0
23502 //
23503 if (!soff) {
23504 return(1);
23505 }
23506 if (n) {
23507 if (gvp == (char*)G__PVOID) {
23508 delete[] (TEvtNavigator*) soff;
23509 } else {
23510 G__setgvp((long) G__PVOID);
23511 for (int i = n - 1; i >= 0; --i) {
23512 ((TEvtNavigator*) (soff+(sizeof(TEvtNavigator)*i)))->~G__TTEvtNavigator();
23513 }
23514 G__setgvp((long)gvp);
23515 }
23516 } else {
23517 if (gvp == (char*)G__PVOID) {
23518 delete (TEvtNavigator*) soff;
23519 } else {
23520 G__setgvp((long) G__PVOID);
23521 ((TEvtNavigator*) (soff))->~G__TTEvtNavigator();
23522 G__setgvp((long)gvp);
23523 }
23524 }
23525 G__setnull(result7);
23526 return(1 || funcname || hash || result7 || libp) ;
23527}
23528
23529// automatic assignment operator
23530static int G__RootEventData_rootcint_503_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23531{
23532 TEvtNavigator* dest = (TEvtNavigator*) G__getstructoffset();
23533 *dest = *(TEvtNavigator*) libp->para[0].ref;
23534 const TEvtNavigator& obj = *dest;
23535 result7->ref = (long) (&obj);
23536 result7->obj.i = (long) (&obj);
23537 return(1 || funcname || hash || result7 || libp) ;
23538}
23539
23540
23541/* TTrigData */
23542static int G__RootEventData_rootcint_507_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23543{
23544 TTrigData* p = NULL;
23545 char* gvp = (char*) G__getgvp();
23546 int n = G__getaryconstruct();
23547 if (n) {
23548 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23549 p = new TTrigData[n];
23550 } else {
23551 p = new((void*) gvp) TTrigData[n];
23552 }
23553 } else {
23554 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23555 p = new TTrigData;
23556 } else {
23557 p = new((void*) gvp) TTrigData;
23558 }
23559 }
23560 result7->obj.i = (long) p;
23561 result7->ref = (long) p;
23562 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData));
23563 return(1 || funcname || hash || result7 || libp) ;
23564}
23565
23566static int G__RootEventData_rootcint_507_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23567{
23568 ((TTrigData*) G__getstructoffset())->setTrigCondition((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
23569 G__setnull(result7);
23570 return(1 || funcname || hash || result7 || libp) ;
23571}
23572
23573static int G__RootEventData_rootcint_507_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23574{
23575 ((TTrigData*) G__getstructoffset())->setTrigCondition((const 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_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23581{
23582 ((TTrigData*) G__getstructoffset())->setTrigChannel((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
23583 G__setnull(result7);
23584 return(1 || funcname || hash || result7 || libp) ;
23585}
23586
23587static int G__RootEventData_rootcint_507_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23588{
23589 ((TTrigData*) G__getstructoffset())->setTrigChannel((const int*) G__int(libp->para[0]));
23590 G__setnull(result7);
23591 return(1 || funcname || hash || result7 || libp) ;
23592}
23593
23594static int G__RootEventData_rootcint_507_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23595{
23596 ((TTrigData*) G__getstructoffset())->setTimeWindow((int) G__int(libp->para[0]));
23597 G__setnull(result7);
23598 return(1 || funcname || hash || result7 || libp) ;
23599}
23600
23601static int G__RootEventData_rootcint_507_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23602{
23603 ((TTrigData*) G__getstructoffset())->setTimingType((int) G__int(libp->para[0]));
23604 G__setnull(result7);
23605 return(1 || funcname || hash || result7 || libp) ;
23606}
23607
23608static int G__RootEventData_rootcint_507_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23609{
23610 ((TTrigData*) G__getstructoffset())->setPreScale((bool) G__int(libp->para[0]));
23611 G__setnull(result7);
23612 return(1 || funcname || hash || result7 || libp) ;
23613}
23614
23615static int G__RootEventData_rootcint_507_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23616{
23617 G__letint(result7, 105, (long) ((const TTrigData*) G__getstructoffset())->getTrigCondition((int) G__int(libp->para[0])));
23618 return(1 || funcname || hash || result7 || libp) ;
23619}
23620
23621static int G__RootEventData_rootcint_507_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23622{
23623 G__letint(result7, 73, (long) ((const TTrigData*) G__getstructoffset())->getTrigCondition());
23624 return(1 || funcname || hash || result7 || libp) ;
23625}
23626
23627static int G__RootEventData_rootcint_507_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23628{
23629 G__letint(result7, 105, (long) ((const TTrigData*) G__getstructoffset())->getTrigChannel((int) G__int(libp->para[0])));
23630 return(1 || funcname || hash || result7 || libp) ;
23631}
23632
23633static int G__RootEventData_rootcint_507_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23634{
23635 G__letint(result7, 73, (long) ((const TTrigData*) G__getstructoffset())->getTrigChannel());
23636 return(1 || funcname || hash || result7 || libp) ;
23637}
23638
23639static int G__RootEventData_rootcint_507_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23640{
23641 G__letint(result7, 105, (long) ((const TTrigData*) G__getstructoffset())->getTimeWindow());
23642 return(1 || funcname || hash || result7 || libp) ;
23643}
23644
23645static int G__RootEventData_rootcint_507_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23646{
23647 G__letint(result7, 105, (long) ((const TTrigData*) G__getstructoffset())->getTimingType());
23648 return(1 || funcname || hash || result7 || libp) ;
23649}
23650
23651static int G__RootEventData_rootcint_507_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23652{
23653 G__letint(result7, 103, (long) ((const TTrigData*) G__getstructoffset())->getPreScale());
23654 return(1 || funcname || hash || result7 || libp) ;
23655}
23656
23657static int G__RootEventData_rootcint_507_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23658{
23659 G__letint(result7, 85, (long) TTrigData::Class());
23660 return(1 || funcname || hash || result7 || libp) ;
23661}
23662
23663static int G__RootEventData_rootcint_507_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23664{
23665 G__letint(result7, 67, (long) TTrigData::Class_Name());
23666 return(1 || funcname || hash || result7 || libp) ;
23667}
23668
23669static int G__RootEventData_rootcint_507_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23670{
23671 G__letint(result7, 115, (long) TTrigData::Class_Version());
23672 return(1 || funcname || hash || result7 || libp) ;
23673}
23674
23675static int G__RootEventData_rootcint_507_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23676{
23677 TTrigData::Dictionary();
23678 G__setnull(result7);
23679 return(1 || funcname || hash || result7 || libp) ;
23680}
23681
23682static int G__RootEventData_rootcint_507_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23683{
23684 ((TTrigData*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
23685 G__setnull(result7);
23686 return(1 || funcname || hash || result7 || libp) ;
23687}
23688
23689static int G__RootEventData_rootcint_507_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23690{
23691 G__letint(result7, 67, (long) TTrigData::DeclFileName());
23692 return(1 || funcname || hash || result7 || libp) ;
23693}
23694
23695static int G__RootEventData_rootcint_507_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23696{
23697 G__letint(result7, 105, (long) TTrigData::ImplFileLine());
23698 return(1 || funcname || hash || result7 || libp) ;
23699}
23700
23701static int G__RootEventData_rootcint_507_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23702{
23703 G__letint(result7, 67, (long) TTrigData::ImplFileName());
23704 return(1 || funcname || hash || result7 || libp) ;
23705}
23706
23707static int G__RootEventData_rootcint_507_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23708{
23709 G__letint(result7, 105, (long) TTrigData::DeclFileLine());
23710 return(1 || funcname || hash || result7 || libp) ;
23711}
23712
23713// automatic copy constructor
23714static int G__RootEventData_rootcint_507_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23715
23716{
23717 TTrigData* p;
23718 void* tmp = (void*) G__int(libp->para[0]);
23719 p = new TTrigData(*(TTrigData*) tmp);
23720 result7->obj.i = (long) p;
23721 result7->ref = (long) p;
23722 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData));
23723 return(1 || funcname || hash || result7 || libp) ;
23724}
23725
23726// automatic destructor
23727typedef TTrigData G__TTTrigData;
23728static int G__RootEventData_rootcint_507_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23729{
23730 char* gvp = (char*) G__getgvp();
23731 long soff = G__getstructoffset();
23732 int n = G__getaryconstruct();
23733 //
23734 //has_a_delete: 1
23735 //has_own_delete1arg: 0
23736 //has_own_delete2arg: 0
23737 //
23738 if (!soff) {
23739 return(1);
23740 }
23741 if (n) {
23742 if (gvp == (char*)G__PVOID) {
23743 delete[] (TTrigData*) soff;
23744 } else {
23745 G__setgvp((long) G__PVOID);
23746 for (int i = n - 1; i >= 0; --i) {
23747 ((TTrigData*) (soff+(sizeof(TTrigData)*i)))->~G__TTTrigData();
23748 }
23749 G__setgvp((long)gvp);
23750 }
23751 } else {
23752 if (gvp == (char*)G__PVOID) {
23753 delete (TTrigData*) soff;
23754 } else {
23755 G__setgvp((long) G__PVOID);
23756 ((TTrigData*) (soff))->~G__TTTrigData();
23757 G__setgvp((long)gvp);
23758 }
23759 }
23760 G__setnull(result7);
23761 return(1 || funcname || hash || result7 || libp) ;
23762}
23763
23764// automatic assignment operator
23765static int G__RootEventData_rootcint_507_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23766{
23767 TTrigData* dest = (TTrigData*) G__getstructoffset();
23768 *dest = *(TTrigData*) libp->para[0].ref;
23769 const TTrigData& obj = *dest;
23770 result7->ref = (long) (&obj);
23771 result7->obj.i = (long) (&obj);
23772 return(1 || funcname || hash || result7 || libp) ;
23773}
23774
23775
23776/* TTrigEvent */
23777static int G__RootEventData_rootcint_508_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23778{
23779 TTrigEvent* p = NULL;
23780 char* gvp = (char*) G__getgvp();
23781 int n = G__getaryconstruct();
23782 if (n) {
23783 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23784 p = new TTrigEvent[n];
23785 } else {
23786 p = new((void*) gvp) TTrigEvent[n];
23787 }
23788 } else {
23789 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23790 p = new TTrigEvent;
23791 } else {
23792 p = new((void*) gvp) TTrigEvent;
23793 }
23794 }
23795 result7->obj.i = (long) p;
23796 result7->ref = (long) p;
23797 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent));
23798 return(1 || funcname || hash || result7 || libp) ;
23799}
23800
23801static int G__RootEventData_rootcint_508_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23802{
23803 ((TTrigEvent*) G__getstructoffset())->initialize();
23804 G__setnull(result7);
23805 return(1 || funcname || hash || result7 || libp) ;
23806}
23807
23808static int G__RootEventData_rootcint_508_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23809{
23810 ((TTrigEvent*) G__getstructoffset())->addTrigData((TTrigData*) G__int(libp->para[0]));
23811 G__setnull(result7);
23812 return(1 || funcname || hash || result7 || libp) ;
23813}
23814
23815static int G__RootEventData_rootcint_508_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23816{
23817 G__letint(result7, 85, (long) ((const TTrigEvent*) G__getstructoffset())->getTrigData());
23818 return(1 || funcname || hash || result7 || libp) ;
23819}
23820
23821static int G__RootEventData_rootcint_508_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23822{
23823 ((TTrigEvent*) G__getstructoffset())->clearTrigData();
23824 G__setnull(result7);
23825 return(1 || funcname || hash || result7 || libp) ;
23826}
23827
23828static int G__RootEventData_rootcint_508_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23829{
23830 G__letint(result7, 85, (long) TTrigEvent::Class());
23831 return(1 || funcname || hash || result7 || libp) ;
23832}
23833
23834static int G__RootEventData_rootcint_508_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23835{
23836 G__letint(result7, 67, (long) TTrigEvent::Class_Name());
23837 return(1 || funcname || hash || result7 || libp) ;
23838}
23839
23840static int G__RootEventData_rootcint_508_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23841{
23842 G__letint(result7, 115, (long) TTrigEvent::Class_Version());
23843 return(1 || funcname || hash || result7 || libp) ;
23844}
23845
23846static int G__RootEventData_rootcint_508_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23847{
23848 TTrigEvent::Dictionary();
23849 G__setnull(result7);
23850 return(1 || funcname || hash || result7 || libp) ;
23851}
23852
23853static int G__RootEventData_rootcint_508_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23854{
23855 ((TTrigEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
23856 G__setnull(result7);
23857 return(1 || funcname || hash || result7 || libp) ;
23858}
23859
23860static int G__RootEventData_rootcint_508_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23861{
23862 G__letint(result7, 67, (long) TTrigEvent::DeclFileName());
23863 return(1 || funcname || hash || result7 || libp) ;
23864}
23865
23866static int G__RootEventData_rootcint_508_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23867{
23868 G__letint(result7, 105, (long) TTrigEvent::ImplFileLine());
23869 return(1 || funcname || hash || result7 || libp) ;
23870}
23871
23872static int G__RootEventData_rootcint_508_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23873{
23874 G__letint(result7, 67, (long) TTrigEvent::ImplFileName());
23875 return(1 || funcname || hash || result7 || libp) ;
23876}
23877
23878static int G__RootEventData_rootcint_508_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23879{
23880 G__letint(result7, 105, (long) TTrigEvent::DeclFileLine());
23881 return(1 || funcname || hash || result7 || libp) ;
23882}
23883
23884// automatic copy constructor
23885static int G__RootEventData_rootcint_508_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23886
23887{
23888 TTrigEvent* p;
23889 void* tmp = (void*) G__int(libp->para[0]);
23890 p = new TTrigEvent(*(TTrigEvent*) tmp);
23891 result7->obj.i = (long) p;
23892 result7->ref = (long) p;
23893 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent));
23894 return(1 || funcname || hash || result7 || libp) ;
23895}
23896
23897// automatic destructor
23898typedef TTrigEvent G__TTTrigEvent;
23899static int G__RootEventData_rootcint_508_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23900{
23901 char* gvp = (char*) G__getgvp();
23902 long soff = G__getstructoffset();
23903 int n = G__getaryconstruct();
23904 //
23905 //has_a_delete: 1
23906 //has_own_delete1arg: 0
23907 //has_own_delete2arg: 0
23908 //
23909 if (!soff) {
23910 return(1);
23911 }
23912 if (n) {
23913 if (gvp == (char*)G__PVOID) {
23914 delete[] (TTrigEvent*) soff;
23915 } else {
23916 G__setgvp((long) G__PVOID);
23917 for (int i = n - 1; i >= 0; --i) {
23918 ((TTrigEvent*) (soff+(sizeof(TTrigEvent)*i)))->~G__TTTrigEvent();
23919 }
23920 G__setgvp((long)gvp);
23921 }
23922 } else {
23923 if (gvp == (char*)G__PVOID) {
23924 delete (TTrigEvent*) soff;
23925 } else {
23926 G__setgvp((long) G__PVOID);
23927 ((TTrigEvent*) (soff))->~G__TTTrigEvent();
23928 G__setgvp((long)gvp);
23929 }
23930 }
23931 G__setnull(result7);
23932 return(1 || funcname || hash || result7 || libp) ;
23933}
23934
23935// automatic assignment operator
23936static int G__RootEventData_rootcint_508_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23937{
23938 TTrigEvent* dest = (TTrigEvent*) G__getstructoffset();
23939 *dest = *(TTrigEvent*) libp->para[0].ref;
23940 const TTrigEvent& obj = *dest;
23941 result7->ref = (long) (&obj);
23942 result7->obj.i = (long) (&obj);
23943 return(1 || funcname || hash || result7 || libp) ;
23944}
23945
23946
23947/* THltRaw */
23948static int G__RootEventData_rootcint_509_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23949{
23950 THltRaw* p = NULL;
23951 char* gvp = (char*) G__getgvp();
23952 int n = G__getaryconstruct();
23953 if (n) {
23954 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23955 p = new THltRaw[n];
23956 } else {
23957 p = new((void*) gvp) THltRaw[n];
23958 }
23959 } else {
23960 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23961 p = new THltRaw;
23962 } else {
23963 p = new((void*) gvp) THltRaw;
23964 }
23965 }
23966 result7->obj.i = (long) p;
23967 result7->ref = (long) p;
23968 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw));
23969 return(1 || funcname || hash || result7 || libp) ;
23970}
23971
23972static int G__RootEventData_rootcint_509_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23973{
23974 G__letint(result7, 85, (long) THltRaw::Class());
23975 return(1 || funcname || hash || result7 || libp) ;
23976}
23977
23978static int G__RootEventData_rootcint_509_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23979{
23980 G__letint(result7, 67, (long) THltRaw::Class_Name());
23981 return(1 || funcname || hash || result7 || libp) ;
23982}
23983
23984static int G__RootEventData_rootcint_509_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23985{
23986 G__letint(result7, 115, (long) THltRaw::Class_Version());
23987 return(1 || funcname || hash || result7 || libp) ;
23988}
23989
23990static int G__RootEventData_rootcint_509_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23991{
23992 THltRaw::Dictionary();
23993 G__setnull(result7);
23994 return(1 || funcname || hash || result7 || libp) ;
23995}
23996
23997static int G__RootEventData_rootcint_509_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23998{
23999 ((THltRaw*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
24000 G__setnull(result7);
24001 return(1 || funcname || hash || result7 || libp) ;
24002}
24003
24004static int G__RootEventData_rootcint_509_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24005{
24006 G__letint(result7, 67, (long) THltRaw::DeclFileName());
24007 return(1 || funcname || hash || result7 || libp) ;
24008}
24009
24010static int G__RootEventData_rootcint_509_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24011{
24012 G__letint(result7, 105, (long) THltRaw::ImplFileLine());
24013 return(1 || funcname || hash || result7 || libp) ;
24014}
24015
24016static int G__RootEventData_rootcint_509_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24017{
24018 G__letint(result7, 67, (long) THltRaw::ImplFileName());
24019 return(1 || funcname || hash || result7 || libp) ;
24020}
24021
24022static int G__RootEventData_rootcint_509_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24023{
24024 G__letint(result7, 105, (long) THltRaw::DeclFileLine());
24025 return(1 || funcname || hash || result7 || libp) ;
24026}
24027
24028// automatic copy constructor
24029static int G__RootEventData_rootcint_509_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24030
24031{
24032 THltRaw* p;
24033 void* tmp = (void*) G__int(libp->para[0]);
24034 p = new THltRaw(*(THltRaw*) tmp);
24035 result7->obj.i = (long) p;
24036 result7->ref = (long) p;
24037 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw));
24038 return(1 || funcname || hash || result7 || libp) ;
24039}
24040
24041// automatic destructor
24042typedef THltRaw G__TTHltRaw;
24043static int G__RootEventData_rootcint_509_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24044{
24045 char* gvp = (char*) G__getgvp();
24046 long soff = G__getstructoffset();
24047 int n = G__getaryconstruct();
24048 //
24049 //has_a_delete: 1
24050 //has_own_delete1arg: 0
24051 //has_own_delete2arg: 0
24052 //
24053 if (!soff) {
24054 return(1);
24055 }
24056 if (n) {
24057 if (gvp == (char*)G__PVOID) {
24058 delete[] (THltRaw*) soff;
24059 } else {
24060 G__setgvp((long) G__PVOID);
24061 for (int i = n - 1; i >= 0; --i) {
24062 ((THltRaw*) (soff+(sizeof(THltRaw)*i)))->~G__TTHltRaw();
24063 }
24064 G__setgvp((long)gvp);
24065 }
24066 } else {
24067 if (gvp == (char*)G__PVOID) {
24068 delete (THltRaw*) soff;
24069 } else {
24070 G__setgvp((long) G__PVOID);
24071 ((THltRaw*) (soff))->~G__TTHltRaw();
24072 G__setgvp((long)gvp);
24073 }
24074 }
24075 G__setnull(result7);
24076 return(1 || funcname || hash || result7 || libp) ;
24077}
24078
24079// automatic assignment operator
24080static int G__RootEventData_rootcint_509_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24081{
24082 THltRaw* dest = (THltRaw*) G__getstructoffset();
24083 *dest = *(THltRaw*) libp->para[0].ref;
24084 const THltRaw& obj = *dest;
24085 result7->ref = (long) (&obj);
24086 result7->obj.i = (long) (&obj);
24087 return(1 || funcname || hash || result7 || libp) ;
24088}
24089
24090
24091/* THltInf */
24092static int G__RootEventData_rootcint_510_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24093{
24094 THltInf* p = NULL;
24095 char* gvp = (char*) G__getgvp();
24096 int n = G__getaryconstruct();
24097 if (n) {
24098 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24099 p = new THltInf[n];
24100 } else {
24101 p = new((void*) gvp) THltInf[n];
24102 }
24103 } else {
24104 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24105 p = new THltInf;
24106 } else {
24107 p = new((void*) gvp) THltInf;
24108 }
24109 }
24110 result7->obj.i = (long) p;
24111 result7->ref = (long) p;
24112 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf));
24113 return(1 || funcname || hash || result7 || libp) ;
24114}
24115
24116static int G__RootEventData_rootcint_510_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24117{
24118 ((THltInf*) G__getstructoffset())->setEventType((const Int_t) G__int(libp->para[0]));
24119 G__setnull(result7);
24120 return(1 || funcname || hash || result7 || libp) ;
24121}
24122
24123static int G__RootEventData_rootcint_510_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24124{
24125 ((THltInf*) G__getstructoffset())->setAlgProcess((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_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24131{
24132 ((THltInf*) G__getstructoffset())->setCriteriaTable((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_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24138{
24139 ((THltInf*) G__getstructoffset())->setVersion((const Int_t) G__int(libp->para[0]));
24140 G__setnull(result7);
24141 return(1 || funcname || hash || result7 || libp) ;
24142}
24143
24144static int G__RootEventData_rootcint_510_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24145{
24146 ((THltInf*) G__getstructoffset())->setTotalEnergy((const Double_t) G__double(libp->para[0]));
24147 G__setnull(result7);
24148 return(1 || funcname || hash || result7 || libp) ;
24149}
24150
24151static int G__RootEventData_rootcint_510_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24152{
24153 ((THltInf*) G__getstructoffset())->setNumber((const Int_t) G__int(libp->para[0]));
24154 G__setnull(result7);
24155 return(1 || funcname || hash || result7 || libp) ;
24156}
24157
24158static int G__RootEventData_rootcint_510_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24159{
24160 ((THltInf*) G__getstructoffset())->setNCON((const Int_t) G__int(libp->para[0]));
24161 G__setnull(result7);
24162 return(1 || funcname || hash || result7 || libp) ;
24163}
24164
24165static int G__RootEventData_rootcint_510_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24166{
24167 ((THltInf*) G__getstructoffset())->setMdcData(*(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_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24173{
24174 ((THltInf*) G__getstructoffset())->setTofData(*(vector<Int_t>*) libp->para[0].ref);
24175 G__setnull(result7);
24176 return(1 || funcname || hash || result7 || libp) ;
24177}
24178
24179static int G__RootEventData_rootcint_510_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24180{
24181 ((THltInf*) G__getstructoffset())->setEmcData(*(vector<Int_t>*) libp->para[0].ref);
24182 G__setnull(result7);
24183 return(1 || funcname || hash || result7 || libp) ;
24184}
24185
24186static int G__RootEventData_rootcint_510_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24187{
24188 ((THltInf*) G__getstructoffset())->setMucData(*(vector<Int_t>*) libp->para[0].ref);
24189 G__setnull(result7);
24190 return(1 || funcname || hash || result7 || libp) ;
24191}
24192
24193static int G__RootEventData_rootcint_510_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24194{
24195 ((THltInf*) G__getstructoffset())->setConData(*(vector<Int_t>*) libp->para[0].ref);
24196 G__setnull(result7);
24197 return(1 || funcname || hash || result7 || libp) ;
24198}
24199
24200static int G__RootEventData_rootcint_510_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24201{
24202 G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getEventType());
24203 return(1 || funcname || hash || result7 || libp) ;
24204}
24205
24206static int G__RootEventData_rootcint_510_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24207{
24208 G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getAlgProcess());
24209 return(1 || funcname || hash || result7 || libp) ;
24210}
24211
24212static int G__RootEventData_rootcint_510_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24213{
24214 G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getCriteriaTable());
24215 return(1 || funcname || hash || result7 || libp) ;
24216}
24217
24218static int G__RootEventData_rootcint_510_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24219{
24220 G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getVersion());
24221 return(1 || funcname || hash || result7 || libp) ;
24222}
24223
24224static int G__RootEventData_rootcint_510_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24225{
24226 G__letdouble(result7, 100, (double) ((const THltInf*) G__getstructoffset())->getTotalEnergy());
24227 return(1 || funcname || hash || result7 || libp) ;
24228}
24229
24230static int G__RootEventData_rootcint_510_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24231{
24232 G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getNumber());
24233 return(1 || funcname || hash || result7 || libp) ;
24234}
24235
24236static int G__RootEventData_rootcint_510_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24237{
24238 G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getNCON());
24239 return(1 || funcname || hash || result7 || libp) ;
24240}
24241
24242static int G__RootEventData_rootcint_510_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24243{
24244 {
24245 const vector<Int_t>* pobj;
24246 const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getMdcData();
24247 pobj = new vector<Int_t>(xobj);
24248 result7->obj.i = (long) ((void*) pobj);
24249 result7->ref = result7->obj.i;
24250 G__store_tempobject(*result7);
24251 }
24252 return(1 || funcname || hash || result7 || libp) ;
24253}
24254
24255static int G__RootEventData_rootcint_510_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24256{
24257 {
24258 const vector<Int_t>* pobj;
24259 const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getTofData();
24260 pobj = new vector<Int_t>(xobj);
24261 result7->obj.i = (long) ((void*) pobj);
24262 result7->ref = result7->obj.i;
24263 G__store_tempobject(*result7);
24264 }
24265 return(1 || funcname || hash || result7 || libp) ;
24266}
24267
24268static int G__RootEventData_rootcint_510_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24269{
24270 {
24271 const vector<Int_t>* pobj;
24272 const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getEmcData();
24273 pobj = new vector<Int_t>(xobj);
24274 result7->obj.i = (long) ((void*) pobj);
24275 result7->ref = result7->obj.i;
24276 G__store_tempobject(*result7);
24277 }
24278 return(1 || funcname || hash || result7 || libp) ;
24279}
24280
24281static int G__RootEventData_rootcint_510_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24282{
24283 {
24284 const vector<Int_t>* pobj;
24285 const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getMucData();
24286 pobj = new vector<Int_t>(xobj);
24287 result7->obj.i = (long) ((void*) pobj);
24288 result7->ref = result7->obj.i;
24289 G__store_tempobject(*result7);
24290 }
24291 return(1 || funcname || hash || result7 || libp) ;
24292}
24293
24294static int G__RootEventData_rootcint_510_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24295{
24296 {
24297 const vector<Int_t>* pobj;
24298 const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getConData();
24299 pobj = new vector<Int_t>(xobj);
24300 result7->obj.i = (long) ((void*) pobj);
24301 result7->ref = result7->obj.i;
24302 G__store_tempobject(*result7);
24303 }
24304 return(1 || funcname || hash || result7 || libp) ;
24305}
24306
24307static int G__RootEventData_rootcint_510_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24308{
24309 G__letint(result7, 85, (long) THltInf::Class());
24310 return(1 || funcname || hash || result7 || libp) ;
24311}
24312
24313static int G__RootEventData_rootcint_510_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24314{
24315 G__letint(result7, 67, (long) THltInf::Class_Name());
24316 return(1 || funcname || hash || result7 || libp) ;
24317}
24318
24319static int G__RootEventData_rootcint_510_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24320{
24321 G__letint(result7, 115, (long) THltInf::Class_Version());
24322 return(1 || funcname || hash || result7 || libp) ;
24323}
24324
24325static int G__RootEventData_rootcint_510_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24326{
24327 THltInf::Dictionary();
24328 G__setnull(result7);
24329 return(1 || funcname || hash || result7 || libp) ;
24330}
24331
24332static int G__RootEventData_rootcint_510_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24333{
24334 ((THltInf*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
24335 G__setnull(result7);
24336 return(1 || funcname || hash || result7 || libp) ;
24337}
24338
24339static int G__RootEventData_rootcint_510_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24340{
24341 G__letint(result7, 67, (long) THltInf::DeclFileName());
24342 return(1 || funcname || hash || result7 || libp) ;
24343}
24344
24345static int G__RootEventData_rootcint_510_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24346{
24347 G__letint(result7, 105, (long) THltInf::ImplFileLine());
24348 return(1 || funcname || hash || result7 || libp) ;
24349}
24350
24351static int G__RootEventData_rootcint_510_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24352{
24353 G__letint(result7, 67, (long) THltInf::ImplFileName());
24354 return(1 || funcname || hash || result7 || libp) ;
24355}
24356
24357static int G__RootEventData_rootcint_510_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24358{
24359 G__letint(result7, 105, (long) THltInf::DeclFileLine());
24360 return(1 || funcname || hash || result7 || libp) ;
24361}
24362
24363// automatic copy constructor
24364static int G__RootEventData_rootcint_510_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24365
24366{
24367 THltInf* p;
24368 void* tmp = (void*) G__int(libp->para[0]);
24369 p = new THltInf(*(THltInf*) tmp);
24370 result7->obj.i = (long) p;
24371 result7->ref = (long) p;
24372 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf));
24373 return(1 || funcname || hash || result7 || libp) ;
24374}
24375
24376// automatic destructor
24377typedef THltInf G__TTHltInf;
24378static int G__RootEventData_rootcint_510_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24379{
24380 char* gvp = (char*) G__getgvp();
24381 long soff = G__getstructoffset();
24382 int n = G__getaryconstruct();
24383 //
24384 //has_a_delete: 1
24385 //has_own_delete1arg: 0
24386 //has_own_delete2arg: 0
24387 //
24388 if (!soff) {
24389 return(1);
24390 }
24391 if (n) {
24392 if (gvp == (char*)G__PVOID) {
24393 delete[] (THltInf*) soff;
24394 } else {
24395 G__setgvp((long) G__PVOID);
24396 for (int i = n - 1; i >= 0; --i) {
24397 ((THltInf*) (soff+(sizeof(THltInf)*i)))->~G__TTHltInf();
24398 }
24399 G__setgvp((long)gvp);
24400 }
24401 } else {
24402 if (gvp == (char*)G__PVOID) {
24403 delete (THltInf*) soff;
24404 } else {
24405 G__setgvp((long) G__PVOID);
24406 ((THltInf*) (soff))->~G__TTHltInf();
24407 G__setgvp((long)gvp);
24408 }
24409 }
24410 G__setnull(result7);
24411 return(1 || funcname || hash || result7 || libp) ;
24412}
24413
24414// automatic assignment operator
24415static int G__RootEventData_rootcint_510_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24416{
24417 THltInf* dest = (THltInf*) G__getstructoffset();
24418 *dest = *(THltInf*) libp->para[0].ref;
24419 const THltInf& obj = *dest;
24420 result7->ref = (long) (&obj);
24421 result7->obj.i = (long) (&obj);
24422 return(1 || funcname || hash || result7 || libp) ;
24423}
24424
24425
24426/* TDstHltInf */
24427static int G__RootEventData_rootcint_511_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24428{
24429 TDstHltInf* p = NULL;
24430 char* gvp = (char*) G__getgvp();
24431 int n = G__getaryconstruct();
24432 if (n) {
24433 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24434 p = new TDstHltInf[n];
24435 } else {
24436 p = new((void*) gvp) TDstHltInf[n];
24437 }
24438 } else {
24439 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24440 p = new TDstHltInf;
24441 } else {
24442 p = new((void*) gvp) TDstHltInf;
24443 }
24444 }
24445 result7->obj.i = (long) p;
24446 result7->ref = (long) p;
24447 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf));
24448 return(1 || funcname || hash || result7 || libp) ;
24449}
24450
24451static int G__RootEventData_rootcint_511_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24452{
24453 ((TDstHltInf*) G__getstructoffset())->setEventType((const Int_t) G__int(libp->para[0]));
24454 G__setnull(result7);
24455 return(1 || funcname || hash || result7 || libp) ;
24456}
24457
24458static int G__RootEventData_rootcint_511_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24459{
24460 ((TDstHltInf*) G__getstructoffset())->setAlgProcess((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_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24466{
24467 ((TDstHltInf*) G__getstructoffset())->setCriteriaTable((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_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24473{
24474 ((TDstHltInf*) G__getstructoffset())->setVersion((const Int_t) G__int(libp->para[0]));
24475 G__setnull(result7);
24476 return(1 || funcname || hash || result7 || libp) ;
24477}
24478
24479static int G__RootEventData_rootcint_511_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24480{
24481 ((TDstHltInf*) G__getstructoffset())->setTotalEnergy((const Double_t) G__double(libp->para[0]));
24482 G__setnull(result7);
24483 return(1 || funcname || hash || result7 || libp) ;
24484}
24485
24486static int G__RootEventData_rootcint_511_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24487{
24488 ((TDstHltInf*) G__getstructoffset())->setNumber((const Int_t) G__int(libp->para[0]));
24489 G__setnull(result7);
24490 return(1 || funcname || hash || result7 || libp) ;
24491}
24492
24493static int G__RootEventData_rootcint_511_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24494{
24495 ((TDstHltInf*) G__getstructoffset())->setNCON((const Int_t) G__int(libp->para[0]));
24496 G__setnull(result7);
24497 return(1 || funcname || hash || result7 || libp) ;
24498}
24499
24500static int G__RootEventData_rootcint_511_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24501{
24502 G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getEventType());
24503 return(1 || funcname || hash || result7 || libp) ;
24504}
24505
24506static int G__RootEventData_rootcint_511_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24507{
24508 G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getAlgProcess());
24509 return(1 || funcname || hash || result7 || libp) ;
24510}
24511
24512static int G__RootEventData_rootcint_511_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24513{
24514 G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getCriteriaTable());
24515 return(1 || funcname || hash || result7 || libp) ;
24516}
24517
24518static int G__RootEventData_rootcint_511_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24519{
24520 G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getVersion());
24521 return(1 || funcname || hash || result7 || libp) ;
24522}
24523
24524static int G__RootEventData_rootcint_511_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24525{
24526 G__letdouble(result7, 100, (double) ((const TDstHltInf*) G__getstructoffset())->getTotalEnergy());
24527 return(1 || funcname || hash || result7 || libp) ;
24528}
24529
24530static int G__RootEventData_rootcint_511_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24531{
24532 G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getNumber());
24533 return(1 || funcname || hash || result7 || libp) ;
24534}
24535
24536static int G__RootEventData_rootcint_511_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24537{
24538 G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getNCON());
24539 return(1 || funcname || hash || result7 || libp) ;
24540}
24541
24542static int G__RootEventData_rootcint_511_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24543{
24544 G__letint(result7, 85, (long) TDstHltInf::Class());
24545 return(1 || funcname || hash || result7 || libp) ;
24546}
24547
24548static int G__RootEventData_rootcint_511_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24549{
24550 G__letint(result7, 67, (long) TDstHltInf::Class_Name());
24551 return(1 || funcname || hash || result7 || libp) ;
24552}
24553
24554static int G__RootEventData_rootcint_511_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24555{
24556 G__letint(result7, 115, (long) TDstHltInf::Class_Version());
24557 return(1 || funcname || hash || result7 || libp) ;
24558}
24559
24560static int G__RootEventData_rootcint_511_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24561{
24562 TDstHltInf::Dictionary();
24563 G__setnull(result7);
24564 return(1 || funcname || hash || result7 || libp) ;
24565}
24566
24567static int G__RootEventData_rootcint_511_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24568{
24569 ((TDstHltInf*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
24570 G__setnull(result7);
24571 return(1 || funcname || hash || result7 || libp) ;
24572}
24573
24574static int G__RootEventData_rootcint_511_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24575{
24576 G__letint(result7, 67, (long) TDstHltInf::DeclFileName());
24577 return(1 || funcname || hash || result7 || libp) ;
24578}
24579
24580static int G__RootEventData_rootcint_511_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24581{
24582 G__letint(result7, 105, (long) TDstHltInf::ImplFileLine());
24583 return(1 || funcname || hash || result7 || libp) ;
24584}
24585
24586static int G__RootEventData_rootcint_511_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24587{
24588 G__letint(result7, 67, (long) TDstHltInf::ImplFileName());
24589 return(1 || funcname || hash || result7 || libp) ;
24590}
24591
24592static int G__RootEventData_rootcint_511_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24593{
24594 G__letint(result7, 105, (long) TDstHltInf::DeclFileLine());
24595 return(1 || funcname || hash || result7 || libp) ;
24596}
24597
24598// automatic copy constructor
24599static int G__RootEventData_rootcint_511_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24600
24601{
24602 TDstHltInf* p;
24603 void* tmp = (void*) G__int(libp->para[0]);
24604 p = new TDstHltInf(*(TDstHltInf*) tmp);
24605 result7->obj.i = (long) p;
24606 result7->ref = (long) p;
24607 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf));
24608 return(1 || funcname || hash || result7 || libp) ;
24609}
24610
24611// automatic destructor
24612typedef TDstHltInf G__TTDstHltInf;
24613static int G__RootEventData_rootcint_511_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24614{
24615 char* gvp = (char*) G__getgvp();
24616 long soff = G__getstructoffset();
24617 int n = G__getaryconstruct();
24618 //
24619 //has_a_delete: 1
24620 //has_own_delete1arg: 0
24621 //has_own_delete2arg: 0
24622 //
24623 if (!soff) {
24624 return(1);
24625 }
24626 if (n) {
24627 if (gvp == (char*)G__PVOID) {
24628 delete[] (TDstHltInf*) soff;
24629 } else {
24630 G__setgvp((long) G__PVOID);
24631 for (int i = n - 1; i >= 0; --i) {
24632 ((TDstHltInf*) (soff+(sizeof(TDstHltInf)*i)))->~G__TTDstHltInf();
24633 }
24634 G__setgvp((long)gvp);
24635 }
24636 } else {
24637 if (gvp == (char*)G__PVOID) {
24638 delete (TDstHltInf*) soff;
24639 } else {
24640 G__setgvp((long) G__PVOID);
24641 ((TDstHltInf*) (soff))->~G__TTDstHltInf();
24642 G__setgvp((long)gvp);
24643 }
24644 }
24645 G__setnull(result7);
24646 return(1 || funcname || hash || result7 || libp) ;
24647}
24648
24649// automatic assignment operator
24650static int G__RootEventData_rootcint_511_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24651{
24652 TDstHltInf* dest = (TDstHltInf*) G__getstructoffset();
24653 *dest = *(TDstHltInf*) libp->para[0].ref;
24654 const TDstHltInf& obj = *dest;
24655 result7->ref = (long) (&obj);
24656 result7->obj.i = (long) (&obj);
24657 return(1 || funcname || hash || result7 || libp) ;
24658}
24659
24660
24661/* THltEvent */
24662static int G__RootEventData_rootcint_512_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24663{
24664 THltEvent* p = NULL;
24665 char* gvp = (char*) G__getgvp();
24666 int n = G__getaryconstruct();
24667 if (n) {
24668 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24669 p = new THltEvent[n];
24670 } else {
24671 p = new((void*) gvp) THltEvent[n];
24672 }
24673 } else {
24674 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24675 p = new THltEvent;
24676 } else {
24677 p = new((void*) gvp) THltEvent;
24678 }
24679 }
24680 result7->obj.i = (long) p;
24681 result7->ref = (long) p;
24682 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent));
24683 return(1 || funcname || hash || result7 || libp) ;
24684}
24685
24686static int G__RootEventData_rootcint_512_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24687{
24688 ((THltEvent*) G__getstructoffset())->initialize();
24689 G__setnull(result7);
24690 return(1 || funcname || hash || result7 || libp) ;
24691}
24692
24693static int G__RootEventData_rootcint_512_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24694{
24695 ((THltEvent*) G__getstructoffset())->addHltRaw((THltRaw*) G__int(libp->para[0]));
24696 G__setnull(result7);
24697 return(1 || funcname || hash || result7 || libp) ;
24698}
24699
24700static int G__RootEventData_rootcint_512_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24701{
24702 G__letint(result7, 85, (long) ((const THltEvent*) G__getstructoffset())->getHltRaw((int) G__int(libp->para[0])));
24703 return(1 || funcname || hash || result7 || libp) ;
24704}
24705
24706static int G__RootEventData_rootcint_512_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24707{
24708 G__letint(result7, 85, (long) ((const THltEvent*) G__getstructoffset())->getHltRawCol());
24709 return(1 || funcname || hash || result7 || libp) ;
24710}
24711
24712static int G__RootEventData_rootcint_512_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24713{
24714 ((THltEvent*) G__getstructoffset())->clearHltRawCol();
24715 G__setnull(result7);
24716 return(1 || funcname || hash || result7 || libp) ;
24717}
24718
24719static int G__RootEventData_rootcint_512_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24720{
24721 ((THltEvent*) G__getstructoffset())->addHltInf((THltInf*) G__int(libp->para[0]));
24722 G__setnull(result7);
24723 return(1 || funcname || hash || result7 || libp) ;
24724}
24725
24726static int G__RootEventData_rootcint_512_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24727{
24728 G__letint(result7, 85, (long) ((const THltEvent*) G__getstructoffset())->getHltInf());
24729 return(1 || funcname || hash || result7 || libp) ;
24730}
24731
24732static int G__RootEventData_rootcint_512_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24733{
24734 ((THltEvent*) G__getstructoffset())->clearHltInf();
24735 G__setnull(result7);
24736 return(1 || funcname || hash || result7 || libp) ;
24737}
24738
24739static int G__RootEventData_rootcint_512_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24740{
24741 ((THltEvent*) G__getstructoffset())->addDstHltInf((TDstHltInf*) G__int(libp->para[0]));
24742 G__setnull(result7);
24743 return(1 || funcname || hash || result7 || libp) ;
24744}
24745
24746static int G__RootEventData_rootcint_512_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24747{
24748 G__letint(result7, 85, (long) ((const THltEvent*) G__getstructoffset())->getDstHltInf());
24749 return(1 || funcname || hash || result7 || libp) ;
24750}
24751
24752static int G__RootEventData_rootcint_512_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24753{
24754 ((THltEvent*) G__getstructoffset())->clearDstHltInf();
24755 G__setnull(result7);
24756 return(1 || funcname || hash || result7 || libp) ;
24757}
24758
24759static int G__RootEventData_rootcint_512_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24760{
24761 G__letint(result7, 85, (long) THltEvent::Class());
24762 return(1 || funcname || hash || result7 || libp) ;
24763}
24764
24765static int G__RootEventData_rootcint_512_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24766{
24767 G__letint(result7, 67, (long) THltEvent::Class_Name());
24768 return(1 || funcname || hash || result7 || libp) ;
24769}
24770
24771static int G__RootEventData_rootcint_512_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24772{
24773 G__letint(result7, 115, (long) THltEvent::Class_Version());
24774 return(1 || funcname || hash || result7 || libp) ;
24775}
24776
24777static int G__RootEventData_rootcint_512_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24778{
24779 THltEvent::Dictionary();
24780 G__setnull(result7);
24781 return(1 || funcname || hash || result7 || libp) ;
24782}
24783
24784static int G__RootEventData_rootcint_512_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24785{
24786 ((THltEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
24787 G__setnull(result7);
24788 return(1 || funcname || hash || result7 || libp) ;
24789}
24790
24791static int G__RootEventData_rootcint_512_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24792{
24793 G__letint(result7, 67, (long) THltEvent::DeclFileName());
24794 return(1 || funcname || hash || result7 || libp) ;
24795}
24796
24797static int G__RootEventData_rootcint_512_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24798{
24799 G__letint(result7, 105, (long) THltEvent::ImplFileLine());
24800 return(1 || funcname || hash || result7 || libp) ;
24801}
24802
24803static int G__RootEventData_rootcint_512_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24804{
24805 G__letint(result7, 67, (long) THltEvent::ImplFileName());
24806 return(1 || funcname || hash || result7 || libp) ;
24807}
24808
24809static int G__RootEventData_rootcint_512_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24810{
24811 G__letint(result7, 105, (long) THltEvent::DeclFileLine());
24812 return(1 || funcname || hash || result7 || libp) ;
24813}
24814
24815// automatic copy constructor
24816static int G__RootEventData_rootcint_512_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24817
24818{
24819 THltEvent* p;
24820 void* tmp = (void*) G__int(libp->para[0]);
24821 p = new THltEvent(*(THltEvent*) tmp);
24822 result7->obj.i = (long) p;
24823 result7->ref = (long) p;
24824 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent));
24825 return(1 || funcname || hash || result7 || libp) ;
24826}
24827
24828// automatic destructor
24829typedef THltEvent G__TTHltEvent;
24830static int G__RootEventData_rootcint_512_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24831{
24832 char* gvp = (char*) G__getgvp();
24833 long soff = G__getstructoffset();
24834 int n = G__getaryconstruct();
24835 //
24836 //has_a_delete: 1
24837 //has_own_delete1arg: 0
24838 //has_own_delete2arg: 0
24839 //
24840 if (!soff) {
24841 return(1);
24842 }
24843 if (n) {
24844 if (gvp == (char*)G__PVOID) {
24845 delete[] (THltEvent*) soff;
24846 } else {
24847 G__setgvp((long) G__PVOID);
24848 for (int i = n - 1; i >= 0; --i) {
24849 ((THltEvent*) (soff+(sizeof(THltEvent)*i)))->~G__TTHltEvent();
24850 }
24851 G__setgvp((long)gvp);
24852 }
24853 } else {
24854 if (gvp == (char*)G__PVOID) {
24855 delete (THltEvent*) soff;
24856 } else {
24857 G__setgvp((long) G__PVOID);
24858 ((THltEvent*) (soff))->~G__TTHltEvent();
24859 G__setgvp((long)gvp);
24860 }
24861 }
24862 G__setnull(result7);
24863 return(1 || funcname || hash || result7 || libp) ;
24864}
24865
24866// automatic assignment operator
24867static int G__RootEventData_rootcint_512_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24868{
24869 THltEvent* dest = (THltEvent*) G__getstructoffset();
24870 *dest = *(THltEvent*) libp->para[0].ref;
24871 const THltEvent& obj = *dest;
24872 result7->ref = (long) (&obj);
24873 result7->obj.i = (long) (&obj);
24874 return(1 || funcname || hash || result7 || libp) ;
24875}
24876
24877
24878/* TDisTrack */
24879static int G__RootEventData_rootcint_513_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24880{
24881 TDisTrack* p = NULL;
24882 char* gvp = (char*) G__getgvp();
24883 int n = G__getaryconstruct();
24884 if (n) {
24885 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24886 p = new TDisTrack[n];
24887 } else {
24888 p = new((void*) gvp) TDisTrack[n];
24889 }
24890 } else {
24891 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24892 p = new TDisTrack;
24893 } else {
24894 p = new((void*) gvp) TDisTrack;
24895 }
24896 }
24897 result7->obj.i = (long) p;
24898 result7->ref = (long) p;
24899 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack));
24900 return(1 || funcname || hash || result7 || libp) ;
24901}
24902
24903static int G__RootEventData_rootcint_513_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24904{
24905 ((TDisTrack*) G__getstructoffset())->initialize();
24906 G__setnull(result7);
24907 return(1 || funcname || hash || result7 || libp) ;
24908}
24909
24910static int G__RootEventData_rootcint_513_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24911{
24912 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getRecMdcTrackCol());
24913 return(1 || funcname || hash || result7 || libp) ;
24914}
24915
24916static int G__RootEventData_rootcint_513_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24917{
24918 ((TDisTrack*) G__getstructoffset())->addRecMdcTrack((TRecMdcTrack*) G__int(libp->para[0]));
24919 G__setnull(result7);
24920 return(1 || funcname || hash || result7 || libp) ;
24921}
24922
24923static int G__RootEventData_rootcint_513_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24924{
24925 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getRecMdcTrack((Int_t) G__int(libp->para[0])));
24926 return(1 || funcname || hash || result7 || libp) ;
24927}
24928
24929static int G__RootEventData_rootcint_513_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24930{
24931 ((TDisTrack*) G__getstructoffset())->clearRecMdcTrackCol();
24932 G__setnull(result7);
24933 return(1 || funcname || hash || result7 || libp) ;
24934}
24935
24936static int G__RootEventData_rootcint_513_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24937{
24938 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getRecMdcHitCol());
24939 return(1 || funcname || hash || result7 || libp) ;
24940}
24941
24942static int G__RootEventData_rootcint_513_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24943{
24944 ((TDisTrack*) G__getstructoffset())->addRecMdcHit((TRecMdcHit*) G__int(libp->para[0]));
24945 G__setnull(result7);
24946 return(1 || funcname || hash || result7 || libp) ;
24947}
24948
24949static int G__RootEventData_rootcint_513_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24950{
24951 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getRecMdcHit((Int_t) G__int(libp->para[0])));
24952 return(1 || funcname || hash || result7 || libp) ;
24953}
24954
24955static int G__RootEventData_rootcint_513_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24956{
24957 ((TDisTrack*) G__getstructoffset())->clearRecMdcHitCol();
24958 G__setnull(result7);
24959 return(1 || funcname || hash || result7 || libp) ;
24960}
24961
24962static int G__RootEventData_rootcint_513_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24963{
24964 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getTofTrackCol());
24965 return(1 || funcname || hash || result7 || libp) ;
24966}
24967
24968static int G__RootEventData_rootcint_513_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24969{
24970 ((TDisTrack*) G__getstructoffset())->addTofTrack((TRecTofTrack*) G__int(libp->para[0]));
24971 G__setnull(result7);
24972 return(1 || funcname || hash || result7 || libp) ;
24973}
24974
24975static int G__RootEventData_rootcint_513_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24976{
24977 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getTofTrack((Int_t) G__int(libp->para[0])));
24978 return(1 || funcname || hash || result7 || libp) ;
24979}
24980
24981static int G__RootEventData_rootcint_513_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24982{
24983 ((TDisTrack*) G__getstructoffset())->clearTofTrackCol();
24984 G__setnull(result7);
24985 return(1 || funcname || hash || result7 || libp) ;
24986}
24987
24988static int G__RootEventData_rootcint_513_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24989{
24990 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getMucTrackCol());
24991 return(1 || funcname || hash || result7 || libp) ;
24992}
24993
24994static int G__RootEventData_rootcint_513_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24995{
24996 ((TDisTrack*) G__getstructoffset())->addMucTrack((TRecMucTrack*) G__int(libp->para[0]));
24997 G__setnull(result7);
24998 return(1 || funcname || hash || result7 || libp) ;
24999}
25000
25001static int G__RootEventData_rootcint_513_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25002{
25003 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getMucTrack((Int_t) G__int(libp->para[0])));
25004 return(1 || funcname || hash || result7 || libp) ;
25005}
25006
25007static int G__RootEventData_rootcint_513_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25008{
25009 ((TDisTrack*) G__getstructoffset())->clearMucTrackCol();
25010 G__setnull(result7);
25011 return(1 || funcname || hash || result7 || libp) ;
25012}
25013
25014static int G__RootEventData_rootcint_513_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25015{
25016 G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getMdcTrackNum());
25017 return(1 || funcname || hash || result7 || libp) ;
25018}
25019
25020static int G__RootEventData_rootcint_513_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25021{
25022 G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getTofTrackNum());
25023 return(1 || funcname || hash || result7 || libp) ;
25024}
25025
25026static int G__RootEventData_rootcint_513_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25027{
25028 G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getEmcShowerNum());
25029 return(1 || funcname || hash || result7 || libp) ;
25030}
25031
25032static int G__RootEventData_rootcint_513_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25033{
25034 G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getMucTrackNum());
25035 return(1 || funcname || hash || result7 || libp) ;
25036}
25037
25038static int G__RootEventData_rootcint_513_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25039{
25040 G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getMdcHitNum());
25041 return(1 || funcname || hash || result7 || libp) ;
25042}
25043
25044static int G__RootEventData_rootcint_513_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25045{
25046 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getEmcShowerCol());
25047 return(1 || funcname || hash || result7 || libp) ;
25048}
25049
25050static int G__RootEventData_rootcint_513_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25051{
25052 ((TDisTrack*) G__getstructoffset())->addEmcShower((TRecEmcShower*) G__int(libp->para[0]));
25053 G__setnull(result7);
25054 return(1 || funcname || hash || result7 || libp) ;
25055}
25056
25057static int G__RootEventData_rootcint_513_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25058{
25059 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getEmcShower((Int_t) G__int(libp->para[0])));
25060 return(1 || funcname || hash || result7 || libp) ;
25061}
25062
25063static int G__RootEventData_rootcint_513_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25064{
25065 ((TDisTrack*) G__getstructoffset())->clearEmcShowerCol();
25066 G__setnull(result7);
25067 return(1 || funcname || hash || result7 || libp) ;
25068}
25069
25070static int G__RootEventData_rootcint_513_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25071{
25072 G__letint(result7, 85, (long) TDisTrack::Class());
25073 return(1 || funcname || hash || result7 || libp) ;
25074}
25075
25076static int G__RootEventData_rootcint_513_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25077{
25078 G__letint(result7, 67, (long) TDisTrack::Class_Name());
25079 return(1 || funcname || hash || result7 || libp) ;
25080}
25081
25082static int G__RootEventData_rootcint_513_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25083{
25084 G__letint(result7, 115, (long) TDisTrack::Class_Version());
25085 return(1 || funcname || hash || result7 || libp) ;
25086}
25087
25088static int G__RootEventData_rootcint_513_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25089{
25090 TDisTrack::Dictionary();
25091 G__setnull(result7);
25092 return(1 || funcname || hash || result7 || libp) ;
25093}
25094
25095static int G__RootEventData_rootcint_513_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25096{
25097 ((TDisTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
25098 G__setnull(result7);
25099 return(1 || funcname || hash || result7 || libp) ;
25100}
25101
25102static int G__RootEventData_rootcint_513_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25103{
25104 G__letint(result7, 67, (long) TDisTrack::DeclFileName());
25105 return(1 || funcname || hash || result7 || libp) ;
25106}
25107
25108static int G__RootEventData_rootcint_513_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25109{
25110 G__letint(result7, 105, (long) TDisTrack::ImplFileLine());
25111 return(1 || funcname || hash || result7 || libp) ;
25112}
25113
25114static int G__RootEventData_rootcint_513_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25115{
25116 G__letint(result7, 67, (long) TDisTrack::ImplFileName());
25117 return(1 || funcname || hash || result7 || libp) ;
25118}
25119
25120static int G__RootEventData_rootcint_513_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25121{
25122 G__letint(result7, 105, (long) TDisTrack::DeclFileLine());
25123 return(1 || funcname || hash || result7 || libp) ;
25124}
25125
25126// automatic copy constructor
25127static int G__RootEventData_rootcint_513_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25128
25129{
25130 TDisTrack* p;
25131 void* tmp = (void*) G__int(libp->para[0]);
25132 p = new TDisTrack(*(TDisTrack*) tmp);
25133 result7->obj.i = (long) p;
25134 result7->ref = (long) p;
25135 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack));
25136 return(1 || funcname || hash || result7 || libp) ;
25137}
25138
25139// automatic destructor
25140typedef TDisTrack G__TTDisTrack;
25141static int G__RootEventData_rootcint_513_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25142{
25143 char* gvp = (char*) G__getgvp();
25144 long soff = G__getstructoffset();
25145 int n = G__getaryconstruct();
25146 //
25147 //has_a_delete: 1
25148 //has_own_delete1arg: 0
25149 //has_own_delete2arg: 0
25150 //
25151 if (!soff) {
25152 return(1);
25153 }
25154 if (n) {
25155 if (gvp == (char*)G__PVOID) {
25156 delete[] (TDisTrack*) soff;
25157 } else {
25158 G__setgvp((long) G__PVOID);
25159 for (int i = n - 1; i >= 0; --i) {
25160 ((TDisTrack*) (soff+(sizeof(TDisTrack)*i)))->~G__TTDisTrack();
25161 }
25162 G__setgvp((long)gvp);
25163 }
25164 } else {
25165 if (gvp == (char*)G__PVOID) {
25166 delete (TDisTrack*) soff;
25167 } else {
25168 G__setgvp((long) G__PVOID);
25169 ((TDisTrack*) (soff))->~G__TTDisTrack();
25170 G__setgvp((long)gvp);
25171 }
25172 }
25173 G__setnull(result7);
25174 return(1 || funcname || hash || result7 || libp) ;
25175}
25176
25177// automatic assignment operator
25178static int G__RootEventData_rootcint_513_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25179{
25180 TDisTrack* dest = (TDisTrack*) G__getstructoffset();
25181 *dest = *(TDisTrack*) libp->para[0].ref;
25182 const TDisTrack& obj = *dest;
25183 result7->ref = (long) (&obj);
25184 result7->obj.i = (long) (&obj);
25185 return(1 || funcname || hash || result7 || libp) ;
25186}
25187
25188
25189/* TEvtRecEvent */
25190static int G__RootEventData_rootcint_514_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25191{
25192 TEvtRecEvent* p = NULL;
25193 char* gvp = (char*) G__getgvp();
25194 int n = G__getaryconstruct();
25195 if (n) {
25196 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25197 p = new TEvtRecEvent[n];
25198 } else {
25199 p = new((void*) gvp) TEvtRecEvent[n];
25200 }
25201 } else {
25202 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25203 p = new TEvtRecEvent;
25204 } else {
25205 p = new((void*) gvp) TEvtRecEvent;
25206 }
25207 }
25208 result7->obj.i = (long) p;
25209 result7->ref = (long) p;
25210 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent));
25211 return(1 || funcname || hash || result7 || libp) ;
25212}
25213
25214static int G__RootEventData_rootcint_514_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25215{
25216 ((TEvtRecEvent*) G__getstructoffset())->initialize();
25217 G__setnull(result7);
25218 return(1 || funcname || hash || result7 || libp) ;
25219}
25220
25221static int G__RootEventData_rootcint_514_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25222{
25223 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->totalTracks());
25224 return(1 || funcname || hash || result7 || libp) ;
25225}
25226
25227static int G__RootEventData_rootcint_514_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25228{
25229 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->totalCharged());
25230 return(1 || funcname || hash || result7 || libp) ;
25231}
25232
25233static int G__RootEventData_rootcint_514_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25234{
25235 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->totalNeutral());
25236 return(1 || funcname || hash || result7 || libp) ;
25237}
25238
25239static int G__RootEventData_rootcint_514_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25240{
25241 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->numberOfVee());
25242 return(1 || funcname || hash || result7 || libp) ;
25243}
25244
25245static int G__RootEventData_rootcint_514_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25246{
25247 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->numberOfPi0());
25248 return(1 || funcname || hash || result7 || libp) ;
25249}
25250
25251static int G__RootEventData_rootcint_514_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25252{
25253 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->numberOfEtaToGG());
25254 return(1 || funcname || hash || result7 || libp) ;
25255}
25256
25257static int G__RootEventData_rootcint_514_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25258{
25259 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->numberOfDTag());
25260 return(1 || funcname || hash || result7 || libp) ;
25261}
25262
25263static int G__RootEventData_rootcint_514_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25264{
25265 ((TEvtRecEvent*) G__getstructoffset())->setTotalTracks((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_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25271{
25272 ((TEvtRecEvent*) G__getstructoffset())->setTotalCharged((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_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25278{
25279 ((TEvtRecEvent*) G__getstructoffset())->setTotalNeutral((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_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25285{
25286 ((TEvtRecEvent*) G__getstructoffset())->setNumberOfVee((const int) G__int(libp->para[0]));
25287 G__setnull(result7);
25288 return(1 || funcname || hash || result7 || libp) ;
25289}
25290
25291static int G__RootEventData_rootcint_514_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25292{
25293 ((TEvtRecEvent*) G__getstructoffset())->setNumberOfPi0((const int) G__int(libp->para[0]));
25294 G__setnull(result7);
25295 return(1 || funcname || hash || result7 || libp) ;
25296}
25297
25298static int G__RootEventData_rootcint_514_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25299{
25300 ((TEvtRecEvent*) G__getstructoffset())->setNumberOfEtaToGG((const int) G__int(libp->para[0]));
25301 G__setnull(result7);
25302 return(1 || funcname || hash || result7 || libp) ;
25303}
25304
25305static int G__RootEventData_rootcint_514_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25306{
25307 ((TEvtRecEvent*) G__getstructoffset())->setNumberOfDTag((const int) G__int(libp->para[0]));
25308 G__setnull(result7);
25309 return(1 || funcname || hash || result7 || libp) ;
25310}
25311
25312static int G__RootEventData_rootcint_514_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25313{
25314 G__letint(result7, 85, (long) TEvtRecEvent::Class());
25315 return(1 || funcname || hash || result7 || libp) ;
25316}
25317
25318static int G__RootEventData_rootcint_514_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25319{
25320 G__letint(result7, 67, (long) TEvtRecEvent::Class_Name());
25321 return(1 || funcname || hash || result7 || libp) ;
25322}
25323
25324static int G__RootEventData_rootcint_514_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25325{
25326 G__letint(result7, 115, (long) TEvtRecEvent::Class_Version());
25327 return(1 || funcname || hash || result7 || libp) ;
25328}
25329
25330static int G__RootEventData_rootcint_514_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25331{
25332 TEvtRecEvent::Dictionary();
25333 G__setnull(result7);
25334 return(1 || funcname || hash || result7 || libp) ;
25335}
25336
25337static int G__RootEventData_rootcint_514_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25338{
25339 ((TEvtRecEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
25340 G__setnull(result7);
25341 return(1 || funcname || hash || result7 || libp) ;
25342}
25343
25344static int G__RootEventData_rootcint_514_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25345{
25346 G__letint(result7, 67, (long) TEvtRecEvent::DeclFileName());
25347 return(1 || funcname || hash || result7 || libp) ;
25348}
25349
25350static int G__RootEventData_rootcint_514_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25351{
25352 G__letint(result7, 105, (long) TEvtRecEvent::ImplFileLine());
25353 return(1 || funcname || hash || result7 || libp) ;
25354}
25355
25356static int G__RootEventData_rootcint_514_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25357{
25358 G__letint(result7, 67, (long) TEvtRecEvent::ImplFileName());
25359 return(1 || funcname || hash || result7 || libp) ;
25360}
25361
25362static int G__RootEventData_rootcint_514_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25363{
25364 G__letint(result7, 105, (long) TEvtRecEvent::DeclFileLine());
25365 return(1 || funcname || hash || result7 || libp) ;
25366}
25367
25368// automatic copy constructor
25369static int G__RootEventData_rootcint_514_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25370
25371{
25372 TEvtRecEvent* p;
25373 void* tmp = (void*) G__int(libp->para[0]);
25374 p = new TEvtRecEvent(*(TEvtRecEvent*) tmp);
25375 result7->obj.i = (long) p;
25376 result7->ref = (long) p;
25377 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent));
25378 return(1 || funcname || hash || result7 || libp) ;
25379}
25380
25381// automatic destructor
25382typedef TEvtRecEvent G__TTEvtRecEvent;
25383static int G__RootEventData_rootcint_514_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25384{
25385 char* gvp = (char*) G__getgvp();
25386 long soff = G__getstructoffset();
25387 int n = G__getaryconstruct();
25388 //
25389 //has_a_delete: 1
25390 //has_own_delete1arg: 0
25391 //has_own_delete2arg: 0
25392 //
25393 if (!soff) {
25394 return(1);
25395 }
25396 if (n) {
25397 if (gvp == (char*)G__PVOID) {
25398 delete[] (TEvtRecEvent*) soff;
25399 } else {
25400 G__setgvp((long) G__PVOID);
25401 for (int i = n - 1; i >= 0; --i) {
25402 ((TEvtRecEvent*) (soff+(sizeof(TEvtRecEvent)*i)))->~G__TTEvtRecEvent();
25403 }
25404 G__setgvp((long)gvp);
25405 }
25406 } else {
25407 if (gvp == (char*)G__PVOID) {
25408 delete (TEvtRecEvent*) soff;
25409 } else {
25410 G__setgvp((long) G__PVOID);
25411 ((TEvtRecEvent*) (soff))->~G__TTEvtRecEvent();
25412 G__setgvp((long)gvp);
25413 }
25414 }
25415 G__setnull(result7);
25416 return(1 || funcname || hash || result7 || libp) ;
25417}
25418
25419// automatic assignment operator
25420static int G__RootEventData_rootcint_514_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25421{
25422 TEvtRecEvent* dest = (TEvtRecEvent*) G__getstructoffset();
25423 *dest = *(TEvtRecEvent*) libp->para[0].ref;
25424 const TEvtRecEvent& obj = *dest;
25425 result7->ref = (long) (&obj);
25426 result7->obj.i = (long) (&obj);
25427 return(1 || funcname || hash || result7 || libp) ;
25428}
25429
25430
25431/* TEvtRecTrack */
25432static int G__RootEventData_rootcint_515_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25433{
25434 TEvtRecTrack* p = NULL;
25435 char* gvp = (char*) G__getgvp();
25436 int n = G__getaryconstruct();
25437 if (n) {
25438 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25439 p = new TEvtRecTrack[n];
25440 } else {
25441 p = new((void*) gvp) TEvtRecTrack[n];
25442 }
25443 } else {
25444 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25445 p = new TEvtRecTrack;
25446 } else {
25447 p = new((void*) gvp) TEvtRecTrack;
25448 }
25449 }
25450 result7->obj.i = (long) p;
25451 result7->ref = (long) p;
25452 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack));
25453 return(1 || funcname || hash || result7 || libp) ;
25454}
25455
25456static int G__RootEventData_rootcint_515_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25457{
25458 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->trackId());
25459 return(1 || funcname || hash || result7 || libp) ;
25460}
25461
25462static int G__RootEventData_rootcint_515_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25463{
25464 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->partId());
25465 return(1 || funcname || hash || result7 || libp) ;
25466}
25467
25468static int G__RootEventData_rootcint_515_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25469{
25470 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->quality());
25471 return(1 || funcname || hash || result7 || libp) ;
25472}
25473
25474static int G__RootEventData_rootcint_515_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25475{
25476 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->mdcTrackId());
25477 return(1 || funcname || hash || result7 || libp) ;
25478}
25479
25480static int G__RootEventData_rootcint_515_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25481{
25482 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->mdcKalTrackId());
25483 return(1 || funcname || hash || result7 || libp) ;
25484}
25485
25486static int G__RootEventData_rootcint_515_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25487{
25488 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->mdcDedxId());
25489 return(1 || funcname || hash || result7 || libp) ;
25490}
25491
25492static int G__RootEventData_rootcint_515_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25493{
25494 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->extTrackId());
25495 return(1 || funcname || hash || result7 || libp) ;
25496}
25497
25498static int G__RootEventData_rootcint_515_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25499{
25500 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->emcShowerId());
25501 return(1 || funcname || hash || result7 || libp) ;
25502}
25503
25504static int G__RootEventData_rootcint_515_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25505{
25506 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->mucTrackId());
25507 return(1 || funcname || hash || result7 || libp) ;
25508}
25509
25510static int G__RootEventData_rootcint_515_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25511{
25512 {
25513 const vector<Int_t>& obj = ((const TEvtRecTrack*) G__getstructoffset())->tofTrackIds();
25514 result7->ref = (long) (&obj);
25515 result7->obj.i = (long) (&obj);
25516 }
25517 return(1 || funcname || hash || result7 || libp) ;
25518}
25519
25520static int G__RootEventData_rootcint_515_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25521{
25522 ((TEvtRecTrack*) G__getstructoffset())->setTrackId((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_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25528{
25529 ((TEvtRecTrack*) G__getstructoffset())->setPartId((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_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25535{
25536 ((TEvtRecTrack*) G__getstructoffset())->setQuality((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_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25542{
25543 ((TEvtRecTrack*) G__getstructoffset())->setMdcTrackId((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_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25549{
25550 ((TEvtRecTrack*) G__getstructoffset())->setMdcKalTrackId((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_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25556{
25557 ((TEvtRecTrack*) G__getstructoffset())->setMdcDedxId((const int) G__int(libp->para[0]));
25558 G__setnull(result7);
25559 return(1 || funcname || hash || result7 || libp) ;
25560}
25561
25562static int G__RootEventData_rootcint_515_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25563{
25564 ((TEvtRecTrack*) G__getstructoffset())->setExtTrackId((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_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25570{
25571 ((TEvtRecTrack*) G__getstructoffset())->setEmcShowerId((const int) G__int(libp->para[0]));
25572 G__setnull(result7);
25573 return(1 || funcname || hash || result7 || libp) ;
25574}
25575
25576static int G__RootEventData_rootcint_515_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25577{
25578 ((TEvtRecTrack*) G__getstructoffset())->setMucTrackId((const int) G__int(libp->para[0]));
25579 G__setnull(result7);
25580 return(1 || funcname || hash || result7 || libp) ;
25581}
25582
25583static int G__RootEventData_rootcint_515_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25584{
25585 ((TEvtRecTrack*) G__getstructoffset())->setTofTrackIds(*(vector<Int_t>*) libp->para[0].ref);
25586 G__setnull(result7);
25587 return(1 || funcname || hash || result7 || libp) ;
25588}
25589
25590static int G__RootEventData_rootcint_515_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25591{
25592 ((TEvtRecTrack*) G__getstructoffset())->addTofTrackId((const int) G__int(libp->para[0]));
25593 G__setnull(result7);
25594 return(1 || funcname || hash || result7 || libp) ;
25595}
25596
25597static int G__RootEventData_rootcint_515_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25598{
25599 G__letint(result7, 85, (long) TEvtRecTrack::Class());
25600 return(1 || funcname || hash || result7 || libp) ;
25601}
25602
25603static int G__RootEventData_rootcint_515_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25604{
25605 G__letint(result7, 67, (long) TEvtRecTrack::Class_Name());
25606 return(1 || funcname || hash || result7 || libp) ;
25607}
25608
25609static int G__RootEventData_rootcint_515_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25610{
25611 G__letint(result7, 115, (long) TEvtRecTrack::Class_Version());
25612 return(1 || funcname || hash || result7 || libp) ;
25613}
25614
25615static int G__RootEventData_rootcint_515_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25616{
25617 TEvtRecTrack::Dictionary();
25618 G__setnull(result7);
25619 return(1 || funcname || hash || result7 || libp) ;
25620}
25621
25622static int G__RootEventData_rootcint_515_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25623{
25624 ((TEvtRecTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
25625 G__setnull(result7);
25626 return(1 || funcname || hash || result7 || libp) ;
25627}
25628
25629static int G__RootEventData_rootcint_515_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25630{
25631 G__letint(result7, 67, (long) TEvtRecTrack::DeclFileName());
25632 return(1 || funcname || hash || result7 || libp) ;
25633}
25634
25635static int G__RootEventData_rootcint_515_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25636{
25637 G__letint(result7, 105, (long) TEvtRecTrack::ImplFileLine());
25638 return(1 || funcname || hash || result7 || libp) ;
25639}
25640
25641static int G__RootEventData_rootcint_515_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25642{
25643 G__letint(result7, 67, (long) TEvtRecTrack::ImplFileName());
25644 return(1 || funcname || hash || result7 || libp) ;
25645}
25646
25647static int G__RootEventData_rootcint_515_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25648{
25649 G__letint(result7, 105, (long) TEvtRecTrack::DeclFileLine());
25650 return(1 || funcname || hash || result7 || libp) ;
25651}
25652
25653// automatic copy constructor
25654static int G__RootEventData_rootcint_515_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25655
25656{
25657 TEvtRecTrack* p;
25658 void* tmp = (void*) G__int(libp->para[0]);
25659 p = new TEvtRecTrack(*(TEvtRecTrack*) tmp);
25660 result7->obj.i = (long) p;
25661 result7->ref = (long) p;
25662 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack));
25663 return(1 || funcname || hash || result7 || libp) ;
25664}
25665
25666// automatic destructor
25667typedef TEvtRecTrack G__TTEvtRecTrack;
25668static int G__RootEventData_rootcint_515_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25669{
25670 char* gvp = (char*) G__getgvp();
25671 long soff = G__getstructoffset();
25672 int n = G__getaryconstruct();
25673 //
25674 //has_a_delete: 1
25675 //has_own_delete1arg: 0
25676 //has_own_delete2arg: 0
25677 //
25678 if (!soff) {
25679 return(1);
25680 }
25681 if (n) {
25682 if (gvp == (char*)G__PVOID) {
25683 delete[] (TEvtRecTrack*) soff;
25684 } else {
25685 G__setgvp((long) G__PVOID);
25686 for (int i = n - 1; i >= 0; --i) {
25687 ((TEvtRecTrack*) (soff+(sizeof(TEvtRecTrack)*i)))->~G__TTEvtRecTrack();
25688 }
25689 G__setgvp((long)gvp);
25690 }
25691 } else {
25692 if (gvp == (char*)G__PVOID) {
25693 delete (TEvtRecTrack*) soff;
25694 } else {
25695 G__setgvp((long) G__PVOID);
25696 ((TEvtRecTrack*) (soff))->~G__TTEvtRecTrack();
25697 G__setgvp((long)gvp);
25698 }
25699 }
25700 G__setnull(result7);
25701 return(1 || funcname || hash || result7 || libp) ;
25702}
25703
25704// automatic assignment operator
25705static int G__RootEventData_rootcint_515_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25706{
25707 TEvtRecTrack* dest = (TEvtRecTrack*) G__getstructoffset();
25708 *dest = *(TEvtRecTrack*) libp->para[0].ref;
25709 const TEvtRecTrack& obj = *dest;
25710 result7->ref = (long) (&obj);
25711 result7->obj.i = (long) (&obj);
25712 return(1 || funcname || hash || result7 || libp) ;
25713}
25714
25715
25716/* TEvtRecPrimaryVertex */
25717static int G__RootEventData_rootcint_516_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25718{
25719 TEvtRecPrimaryVertex* p = NULL;
25720 char* gvp = (char*) G__getgvp();
25721 int n = G__getaryconstruct();
25722 if (n) {
25723 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25724 p = new TEvtRecPrimaryVertex[n];
25725 } else {
25726 p = new((void*) gvp) TEvtRecPrimaryVertex[n];
25727 }
25728 } else {
25729 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25730 p = new TEvtRecPrimaryVertex;
25731 } else {
25732 p = new((void*) gvp) TEvtRecPrimaryVertex;
25733 }
25734 }
25735 result7->obj.i = (long) p;
25736 result7->ref = (long) p;
25737 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex));
25738 return(1 || funcname || hash || result7 || libp) ;
25739}
25740
25741static int G__RootEventData_rootcint_516_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25742{
25743 G__letint(result7, 103, (long) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->isValid());
25744 return(1 || funcname || hash || result7 || libp) ;
25745}
25746
25747static int G__RootEventData_rootcint_516_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25748{
25749 G__letint(result7, 105, (long) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->nTracks());
25750 return(1 || funcname || hash || result7 || libp) ;
25751}
25752
25753static int G__RootEventData_rootcint_516_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25754{
25755 {
25756 const vector<Int_t>& obj = ((const TEvtRecPrimaryVertex*) G__getstructoffset())->trackIdList();
25757 result7->ref = (long) (&obj);
25758 result7->obj.i = (long) (&obj);
25759 }
25760 return(1 || funcname || hash || result7 || libp) ;
25761}
25762
25763static int G__RootEventData_rootcint_516_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25764{
25765 G__letdouble(result7, 100, (double) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->chi2());
25766 return(1 || funcname || hash || result7 || libp) ;
25767}
25768
25769static int G__RootEventData_rootcint_516_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25770{
25771 G__letint(result7, 105, (long) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->ndof());
25772 return(1 || funcname || hash || result7 || libp) ;
25773}
25774
25775static int G__RootEventData_rootcint_516_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25776{
25777 G__letint(result7, 105, (long) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->fitMethod());
25778 return(1 || funcname || hash || result7 || libp) ;
25779}
25780
25781static int G__RootEventData_rootcint_516_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25782{
25783 G__letdouble(result7, 100, (double) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->vertex((Int_t) G__int(libp->para[0])));
25784 return(1 || funcname || hash || result7 || libp) ;
25785}
25786
25787static int G__RootEventData_rootcint_516_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25788{
25789 G__letdouble(result7, 100, (double) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->errorVertex((Int_t) G__int(libp->para[0])));
25790 return(1 || funcname || hash || result7 || libp) ;
25791}
25792
25793static int G__RootEventData_rootcint_516_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25794{
25795 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setIsValid((Bool_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_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25801{
25802 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setNTracks((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_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25808{
25809 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setTrackIdList(*(vector<Int_t>*) libp->para[0].ref);
25810 G__setnull(result7);
25811 return(1 || funcname || hash || result7 || libp) ;
25812}
25813
25814static int G__RootEventData_rootcint_516_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25815{
25816 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setChi2((Double_t) G__double(libp->para[0]));
25817 G__setnull(result7);
25818 return(1 || funcname || hash || result7 || libp) ;
25819}
25820
25821static int G__RootEventData_rootcint_516_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25822{
25823 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setNdof((Int_t) G__int(libp->para[0]));
25824 G__setnull(result7);
25825 return(1 || funcname || hash || result7 || libp) ;
25826}
25827
25828static int G__RootEventData_rootcint_516_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25829{
25830 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setFitMethod((Int_t) G__int(libp->para[0]));
25831 G__setnull(result7);
25832 return(1 || funcname || hash || result7 || libp) ;
25833}
25834
25835static int G__RootEventData_rootcint_516_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25836{
25837 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setVertex((Double_t*) G__int(libp->para[0]));
25838 G__setnull(result7);
25839 return(1 || funcname || hash || result7 || libp) ;
25840}
25841
25842static int G__RootEventData_rootcint_516_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25843{
25844 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setErrorVertex((Double_t*) G__int(libp->para[0]));
25845 G__setnull(result7);
25846 return(1 || funcname || hash || result7 || libp) ;
25847}
25848
25849static int G__RootEventData_rootcint_516_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25850{
25851 G__letint(result7, 85, (long) TEvtRecPrimaryVertex::Class());
25852 return(1 || funcname || hash || result7 || libp) ;
25853}
25854
25855static int G__RootEventData_rootcint_516_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25856{
25857 G__letint(result7, 67, (long) TEvtRecPrimaryVertex::Class_Name());
25858 return(1 || funcname || hash || result7 || libp) ;
25859}
25860
25861static int G__RootEventData_rootcint_516_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25862{
25863 G__letint(result7, 115, (long) TEvtRecPrimaryVertex::Class_Version());
25864 return(1 || funcname || hash || result7 || libp) ;
25865}
25866
25867static int G__RootEventData_rootcint_516_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25868{
25869 TEvtRecPrimaryVertex::Dictionary();
25870 G__setnull(result7);
25871 return(1 || funcname || hash || result7 || libp) ;
25872}
25873
25874static int G__RootEventData_rootcint_516_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25875{
25876 ((TEvtRecPrimaryVertex*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
25877 G__setnull(result7);
25878 return(1 || funcname || hash || result7 || libp) ;
25879}
25880
25881static int G__RootEventData_rootcint_516_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25882{
25883 G__letint(result7, 67, (long) TEvtRecPrimaryVertex::DeclFileName());
25884 return(1 || funcname || hash || result7 || libp) ;
25885}
25886
25887static int G__RootEventData_rootcint_516_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25888{
25889 G__letint(result7, 105, (long) TEvtRecPrimaryVertex::ImplFileLine());
25890 return(1 || funcname || hash || result7 || libp) ;
25891}
25892
25893static int G__RootEventData_rootcint_516_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25894{
25895 G__letint(result7, 67, (long) TEvtRecPrimaryVertex::ImplFileName());
25896 return(1 || funcname || hash || result7 || libp) ;
25897}
25898
25899static int G__RootEventData_rootcint_516_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25900{
25901 G__letint(result7, 105, (long) TEvtRecPrimaryVertex::DeclFileLine());
25902 return(1 || funcname || hash || result7 || libp) ;
25903}
25904
25905// automatic copy constructor
25906static int G__RootEventData_rootcint_516_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25907
25908{
25909 TEvtRecPrimaryVertex* p;
25910 void* tmp = (void*) G__int(libp->para[0]);
25911 p = new TEvtRecPrimaryVertex(*(TEvtRecPrimaryVertex*) tmp);
25912 result7->obj.i = (long) p;
25913 result7->ref = (long) p;
25914 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex));
25915 return(1 || funcname || hash || result7 || libp) ;
25916}
25917
25918// automatic destructor
25919typedef TEvtRecPrimaryVertex G__TTEvtRecPrimaryVertex;
25920static int G__RootEventData_rootcint_516_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25921{
25922 char* gvp = (char*) G__getgvp();
25923 long soff = G__getstructoffset();
25924 int n = G__getaryconstruct();
25925 //
25926 //has_a_delete: 1
25927 //has_own_delete1arg: 0
25928 //has_own_delete2arg: 0
25929 //
25930 if (!soff) {
25931 return(1);
25932 }
25933 if (n) {
25934 if (gvp == (char*)G__PVOID) {
25935 delete[] (TEvtRecPrimaryVertex*) soff;
25936 } else {
25937 G__setgvp((long) G__PVOID);
25938 for (int i = n - 1; i >= 0; --i) {
25939 ((TEvtRecPrimaryVertex*) (soff+(sizeof(TEvtRecPrimaryVertex)*i)))->~G__TTEvtRecPrimaryVertex();
25940 }
25941 G__setgvp((long)gvp);
25942 }
25943 } else {
25944 if (gvp == (char*)G__PVOID) {
25945 delete (TEvtRecPrimaryVertex*) soff;
25946 } else {
25947 G__setgvp((long) G__PVOID);
25948 ((TEvtRecPrimaryVertex*) (soff))->~G__TTEvtRecPrimaryVertex();
25949 G__setgvp((long)gvp);
25950 }
25951 }
25952 G__setnull(result7);
25953 return(1 || funcname || hash || result7 || libp) ;
25954}
25955
25956// automatic assignment operator
25957static int G__RootEventData_rootcint_516_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25958{
25959 TEvtRecPrimaryVertex* dest = (TEvtRecPrimaryVertex*) G__getstructoffset();
25960 *dest = *(TEvtRecPrimaryVertex*) libp->para[0].ref;
25961 const TEvtRecPrimaryVertex& obj = *dest;
25962 result7->ref = (long) (&obj);
25963 result7->obj.i = (long) (&obj);
25964 return(1 || funcname || hash || result7 || libp) ;
25965}
25966
25967
25968/* TEvtRecVeeVertex */
25969static int G__RootEventData_rootcint_517_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25970{
25971 TEvtRecVeeVertex* p = NULL;
25972 char* gvp = (char*) G__getgvp();
25973 int n = G__getaryconstruct();
25974 if (n) {
25975 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25976 p = new TEvtRecVeeVertex[n];
25977 } else {
25978 p = new((void*) gvp) TEvtRecVeeVertex[n];
25979 }
25980 } else {
25981 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25982 p = new TEvtRecVeeVertex;
25983 } else {
25984 p = new((void*) gvp) TEvtRecVeeVertex;
25985 }
25986 }
25987 result7->obj.i = (long) p;
25988 result7->ref = (long) p;
25989 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex));
25990 return(1 || funcname || hash || result7 || libp) ;
25991}
25992
25993static int G__RootEventData_rootcint_517_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25994{
25995 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->vertexId());
25996 return(1 || funcname || hash || result7 || libp) ;
25997}
25998
25999static int G__RootEventData_rootcint_517_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26000{
26001 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->vertexType());
26002 return(1 || funcname || hash || result7 || libp) ;
26003}
26004
26005static int G__RootEventData_rootcint_517_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26006{
26007 G__letdouble(result7, 100, (double) ((const TEvtRecVeeVertex*) G__getstructoffset())->chi2());
26008 return(1 || funcname || hash || result7 || libp) ;
26009}
26010
26011static int G__RootEventData_rootcint_517_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26012{
26013 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->ndof());
26014 return(1 || funcname || hash || result7 || libp) ;
26015}
26016
26017static int G__RootEventData_rootcint_517_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26018{
26019 G__letdouble(result7, 100, (double) ((const TEvtRecVeeVertex*) G__getstructoffset())->mass());
26020 return(1 || funcname || hash || result7 || libp) ;
26021}
26022
26023static int G__RootEventData_rootcint_517_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26024{
26025 G__letdouble(result7, 100, (double) ((const TEvtRecVeeVertex*) G__getstructoffset())->w((Int_t) G__int(libp->para[0])));
26026 return(1 || funcname || hash || result7 || libp) ;
26027}
26028
26029static int G__RootEventData_rootcint_517_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26030{
26031 G__letdouble(result7, 100, (double) ((const TEvtRecVeeVertex*) G__getstructoffset())->Ew((Int_t) G__int(libp->para[0])));
26032 return(1 || funcname || hash || result7 || libp) ;
26033}
26034
26035static int G__RootEventData_rootcint_517_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26036{
26037 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->pair((Int_t) G__int(libp->para[0])));
26038 return(1 || funcname || hash || result7 || libp) ;
26039}
26040
26041static int G__RootEventData_rootcint_517_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26042{
26043 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->nCharge());
26044 return(1 || funcname || hash || result7 || libp) ;
26045}
26046
26047static int G__RootEventData_rootcint_517_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26048{
26049 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->nTracks());
26050 return(1 || funcname || hash || result7 || libp) ;
26051}
26052
26053static int G__RootEventData_rootcint_517_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26054{
26055 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->daughter((Int_t) G__int(libp->para[0])));
26056 return(1 || funcname || hash || result7 || libp) ;
26057}
26058
26059static int G__RootEventData_rootcint_517_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26060{
26061 ((TEvtRecVeeVertex*) G__getstructoffset())->setVertexId((Int_t) G__int(libp->para[0]));
26062 G__setnull(result7);
26063 return(1 || funcname || hash || result7 || libp) ;
26064}
26065
26066static int G__RootEventData_rootcint_517_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26067{
26068 ((TEvtRecVeeVertex*) G__getstructoffset())->setVertexType((Int_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_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26074{
26075 ((TEvtRecVeeVertex*) G__getstructoffset())->setChi2((Double_t) G__double(libp->para[0]));
26076 G__setnull(result7);
26077 return(1 || funcname || hash || result7 || libp) ;
26078}
26079
26080static int G__RootEventData_rootcint_517_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26081{
26082 ((TEvtRecVeeVertex*) G__getstructoffset())->setNdof((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_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26088{
26089 ((TEvtRecVeeVertex*) G__getstructoffset())->setMass((Double_t) G__double(libp->para[0]));
26090 G__setnull(result7);
26091 return(1 || funcname || hash || result7 || libp) ;
26092}
26093
26094static int G__RootEventData_rootcint_517_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26095{
26096 ((TEvtRecVeeVertex*) G__getstructoffset())->setW((Double_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_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26102{
26103 ((TEvtRecVeeVertex*) G__getstructoffset())->setEw((Double_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_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26109{
26110 ((TEvtRecVeeVertex*) G__getstructoffset())->setPair((Int_t*) G__int(libp->para[0]));
26111 G__setnull(result7);
26112 return(1 || funcname || hash || result7 || libp) ;
26113}
26114
26115static int G__RootEventData_rootcint_517_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26116{
26117 ((TEvtRecVeeVertex*) G__getstructoffset())->setNCharge((Int_t) G__int(libp->para[0]));
26118 G__setnull(result7);
26119 return(1 || funcname || hash || result7 || libp) ;
26120}
26121
26122static int G__RootEventData_rootcint_517_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26123{
26124 ((TEvtRecVeeVertex*) G__getstructoffset())->setNTracks((Int_t) G__int(libp->para[0]));
26125 G__setnull(result7);
26126 return(1 || funcname || hash || result7 || libp) ;
26127}
26128
26129static int G__RootEventData_rootcint_517_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26130{
26131 ((TEvtRecVeeVertex*) G__getstructoffset())->setDaughter((Int_t*) G__int(libp->para[0]));
26132 G__setnull(result7);
26133 return(1 || funcname || hash || result7 || libp) ;
26134}
26135
26136static int G__RootEventData_rootcint_517_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26137{
26138 G__letint(result7, 85, (long) TEvtRecVeeVertex::Class());
26139 return(1 || funcname || hash || result7 || libp) ;
26140}
26141
26142static int G__RootEventData_rootcint_517_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26143{
26144 G__letint(result7, 67, (long) TEvtRecVeeVertex::Class_Name());
26145 return(1 || funcname || hash || result7 || libp) ;
26146}
26147
26148static int G__RootEventData_rootcint_517_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26149{
26150 G__letint(result7, 115, (long) TEvtRecVeeVertex::Class_Version());
26151 return(1 || funcname || hash || result7 || libp) ;
26152}
26153
26154static int G__RootEventData_rootcint_517_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26155{
26156 TEvtRecVeeVertex::Dictionary();
26157 G__setnull(result7);
26158 return(1 || funcname || hash || result7 || libp) ;
26159}
26160
26161static int G__RootEventData_rootcint_517_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26162{
26163 ((TEvtRecVeeVertex*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
26164 G__setnull(result7);
26165 return(1 || funcname || hash || result7 || libp) ;
26166}
26167
26168static int G__RootEventData_rootcint_517_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26169{
26170 G__letint(result7, 67, (long) TEvtRecVeeVertex::DeclFileName());
26171 return(1 || funcname || hash || result7 || libp) ;
26172}
26173
26174static int G__RootEventData_rootcint_517_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26175{
26176 G__letint(result7, 105, (long) TEvtRecVeeVertex::ImplFileLine());
26177 return(1 || funcname || hash || result7 || libp) ;
26178}
26179
26180static int G__RootEventData_rootcint_517_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26181{
26182 G__letint(result7, 67, (long) TEvtRecVeeVertex::ImplFileName());
26183 return(1 || funcname || hash || result7 || libp) ;
26184}
26185
26186static int G__RootEventData_rootcint_517_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26187{
26188 G__letint(result7, 105, (long) TEvtRecVeeVertex::DeclFileLine());
26189 return(1 || funcname || hash || result7 || libp) ;
26190}
26191
26192// automatic copy constructor
26193static int G__RootEventData_rootcint_517_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26194
26195{
26196 TEvtRecVeeVertex* p;
26197 void* tmp = (void*) G__int(libp->para[0]);
26198 p = new TEvtRecVeeVertex(*(TEvtRecVeeVertex*) tmp);
26199 result7->obj.i = (long) p;
26200 result7->ref = (long) p;
26201 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex));
26202 return(1 || funcname || hash || result7 || libp) ;
26203}
26204
26205// automatic destructor
26206typedef TEvtRecVeeVertex G__TTEvtRecVeeVertex;
26207static int G__RootEventData_rootcint_517_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26208{
26209 char* gvp = (char*) G__getgvp();
26210 long soff = G__getstructoffset();
26211 int n = G__getaryconstruct();
26212 //
26213 //has_a_delete: 1
26214 //has_own_delete1arg: 0
26215 //has_own_delete2arg: 0
26216 //
26217 if (!soff) {
26218 return(1);
26219 }
26220 if (n) {
26221 if (gvp == (char*)G__PVOID) {
26222 delete[] (TEvtRecVeeVertex*) soff;
26223 } else {
26224 G__setgvp((long) G__PVOID);
26225 for (int i = n - 1; i >= 0; --i) {
26226 ((TEvtRecVeeVertex*) (soff+(sizeof(TEvtRecVeeVertex)*i)))->~G__TTEvtRecVeeVertex();
26227 }
26228 G__setgvp((long)gvp);
26229 }
26230 } else {
26231 if (gvp == (char*)G__PVOID) {
26232 delete (TEvtRecVeeVertex*) soff;
26233 } else {
26234 G__setgvp((long) G__PVOID);
26235 ((TEvtRecVeeVertex*) (soff))->~G__TTEvtRecVeeVertex();
26236 G__setgvp((long)gvp);
26237 }
26238 }
26239 G__setnull(result7);
26240 return(1 || funcname || hash || result7 || libp) ;
26241}
26242
26243// automatic assignment operator
26244static int G__RootEventData_rootcint_517_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26245{
26246 TEvtRecVeeVertex* dest = (TEvtRecVeeVertex*) G__getstructoffset();
26247 *dest = *(TEvtRecVeeVertex*) libp->para[0].ref;
26248 const TEvtRecVeeVertex& obj = *dest;
26249 result7->ref = (long) (&obj);
26250 result7->obj.i = (long) (&obj);
26251 return(1 || funcname || hash || result7 || libp) ;
26252}
26253
26254
26255/* TEvtRecPi0 */
26256static int G__RootEventData_rootcint_518_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26257{
26258 TEvtRecPi0* p = NULL;
26259 char* gvp = (char*) G__getgvp();
26260 int n = G__getaryconstruct();
26261 if (n) {
26262 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
26263 p = new TEvtRecPi0[n];
26264 } else {
26265 p = new((void*) gvp) TEvtRecPi0[n];
26266 }
26267 } else {
26268 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
26269 p = new TEvtRecPi0;
26270 } else {
26271 p = new((void*) gvp) TEvtRecPi0;
26272 }
26273 }
26274 result7->obj.i = (long) p;
26275 result7->ref = (long) p;
26276 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0));
26277 return(1 || funcname || hash || result7 || libp) ;
26278}
26279
26280static int G__RootEventData_rootcint_518_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26281{
26282 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->unconMass());
26283 return(1 || funcname || hash || result7 || libp) ;
26284}
26285
26286static int G__RootEventData_rootcint_518_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26287{
26288 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->chisq());
26289 return(1 || funcname || hash || result7 || libp) ;
26290}
26291
26292static int G__RootEventData_rootcint_518_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26293{
26294 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->hiPxfit());
26295 return(1 || funcname || hash || result7 || libp) ;
26296}
26297
26298static int G__RootEventData_rootcint_518_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26299{
26300 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->hiPyfit());
26301 return(1 || funcname || hash || result7 || libp) ;
26302}
26303
26304static int G__RootEventData_rootcint_518_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26305{
26306 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->hiPzfit());
26307 return(1 || funcname || hash || result7 || libp) ;
26308}
26309
26310static int G__RootEventData_rootcint_518_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26311{
26312 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->hiPefit());
26313 return(1 || funcname || hash || result7 || libp) ;
26314}
26315
26316static int G__RootEventData_rootcint_518_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26317{
26318 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->loPxfit());
26319 return(1 || funcname || hash || result7 || libp) ;
26320}
26321
26322static int G__RootEventData_rootcint_518_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26323{
26324 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->loPyfit());
26325 return(1 || funcname || hash || result7 || libp) ;
26326}
26327
26328static int G__RootEventData_rootcint_518_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26329{
26330 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->loPzfit());
26331 return(1 || funcname || hash || result7 || libp) ;
26332}
26333
26334static int G__RootEventData_rootcint_518_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26335{
26336 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->loPefit());
26337 return(1 || funcname || hash || result7 || libp) ;
26338}
26339
26340static int G__RootEventData_rootcint_518_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26341{
26342 G__letint(result7, 105, (long) ((const TEvtRecPi0*) G__getstructoffset())->hiEnGamma());
26343 return(1 || funcname || hash || result7 || libp) ;
26344}
26345
26346static int G__RootEventData_rootcint_518_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26347{
26348 G__letint(result7, 105, (long) ((const TEvtRecPi0*) G__getstructoffset())->loEnGamma());
26349 return(1 || funcname || hash || result7 || libp) ;
26350}
26351
26352static int G__RootEventData_rootcint_518_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26353{
26354 ((TEvtRecPi0*) G__getstructoffset())->setUnconMass((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_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26360{
26361 ((TEvtRecPi0*) G__getstructoffset())->setChisq((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_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26367{
26368 ((TEvtRecPi0*) G__getstructoffset())->setHiPxfit((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_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26374{
26375 ((TEvtRecPi0*) G__getstructoffset())->setHiPyfit((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_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26381{
26382 ((TEvtRecPi0*) G__getstructoffset())->setHiPzfit((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_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26388{
26389 ((TEvtRecPi0*) G__getstructoffset())->setHiPefit((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_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26395{
26396 ((TEvtRecPi0*) G__getstructoffset())->setLoPxfit((Double_t) G__double(libp->para[0]));
26397 G__setnull(result7);
26398 return(1 || funcname || hash || result7 || libp) ;
26399}
26400
26401static int G__RootEventData_rootcint_518_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26402{
26403 ((TEvtRecPi0*) G__getstructoffset())->setLoPyfit((Double_t) G__double(libp->para[0]));
26404 G__setnull(result7);
26405 return(1 || funcname || hash || result7 || libp) ;
26406}
26407
26408static int G__RootEventData_rootcint_518_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26409{
26410 ((TEvtRecPi0*) G__getstructoffset())->setLoPzfit((Double_t) G__double(libp->para[0]));
26411 G__setnull(result7);
26412 return(1 || funcname || hash || result7 || libp) ;
26413}
26414
26415static int G__RootEventData_rootcint_518_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26416{
26417 ((TEvtRecPi0*) G__getstructoffset())->setLoPefit((Double_t) G__double(libp->para[0]));
26418 G__setnull(result7);
26419 return(1 || funcname || hash || result7 || libp) ;
26420}
26421
26422static int G__RootEventData_rootcint_518_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26423{
26424 ((TEvtRecPi0*) G__getstructoffset())->setHiEnGamma((Int_t) G__int(libp->para[0]));
26425 G__setnull(result7);
26426 return(1 || funcname || hash || result7 || libp) ;
26427}
26428
26429static int G__RootEventData_rootcint_518_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26430{
26431 ((TEvtRecPi0*) G__getstructoffset())->setLoEnGamma((Int_t) G__int(libp->para[0]));
26432 G__setnull(result7);
26433 return(1 || funcname || hash || result7 || libp) ;
26434}
26435
26436static int G__RootEventData_rootcint_518_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26437{
26438 G__letint(result7, 85, (long) TEvtRecPi0::Class());
26439 return(1 || funcname || hash || result7 || libp) ;
26440}
26441
26442static int G__RootEventData_rootcint_518_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26443{
26444 G__letint(result7, 67, (long) TEvtRecPi0::Class_Name());
26445 return(1 || funcname || hash || result7 || libp) ;
26446}
26447
26448static int G__RootEventData_rootcint_518_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26449{
26450 G__letint(result7, 115, (long) TEvtRecPi0::Class_Version());
26451 return(1 || funcname || hash || result7 || libp) ;
26452}
26453
26454static int G__RootEventData_rootcint_518_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26455{
26456 TEvtRecPi0::Dictionary();
26457 G__setnull(result7);
26458 return(1 || funcname || hash || result7 || libp) ;
26459}
26460
26461static int G__RootEventData_rootcint_518_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26462{
26463 ((TEvtRecPi0*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
26464 G__setnull(result7);
26465 return(1 || funcname || hash || result7 || libp) ;
26466}
26467
26468static int G__RootEventData_rootcint_518_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26469{
26470 G__letint(result7, 67, (long) TEvtRecPi0::DeclFileName());
26471 return(1 || funcname || hash || result7 || libp) ;
26472}
26473
26474static int G__RootEventData_rootcint_518_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26475{
26476 G__letint(result7, 105, (long) TEvtRecPi0::ImplFileLine());
26477 return(1 || funcname || hash || result7 || libp) ;
26478}
26479
26480static int G__RootEventData_rootcint_518_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26481{
26482 G__letint(result7, 67, (long) TEvtRecPi0::ImplFileName());
26483 return(1 || funcname || hash || result7 || libp) ;
26484}
26485
26486static int G__RootEventData_rootcint_518_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26487{
26488 G__letint(result7, 105, (long) TEvtRecPi0::DeclFileLine());
26489 return(1 || funcname || hash || result7 || libp) ;
26490}
26491
26492// automatic copy constructor
26493static int G__RootEventData_rootcint_518_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26494
26495{
26496 TEvtRecPi0* p;
26497 void* tmp = (void*) G__int(libp->para[0]);
26498 p = new TEvtRecPi0(*(TEvtRecPi0*) tmp);
26499 result7->obj.i = (long) p;
26500 result7->ref = (long) p;
26501 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0));
26502 return(1 || funcname || hash || result7 || libp) ;
26503}
26504
26505// automatic destructor
26506typedef TEvtRecPi0 G__TTEvtRecPi0;
26507static int G__RootEventData_rootcint_518_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26508{
26509 char* gvp = (char*) G__getgvp();
26510 long soff = G__getstructoffset();
26511 int n = G__getaryconstruct();
26512 //
26513 //has_a_delete: 1
26514 //has_own_delete1arg: 0
26515 //has_own_delete2arg: 0
26516 //
26517 if (!soff) {
26518 return(1);
26519 }
26520 if (n) {
26521 if (gvp == (char*)G__PVOID) {
26522 delete[] (TEvtRecPi0*) soff;
26523 } else {
26524 G__setgvp((long) G__PVOID);
26525 for (int i = n - 1; i >= 0; --i) {
26526 ((TEvtRecPi0*) (soff+(sizeof(TEvtRecPi0)*i)))->~G__TTEvtRecPi0();
26527 }
26528 G__setgvp((long)gvp);
26529 }
26530 } else {
26531 if (gvp == (char*)G__PVOID) {
26532 delete (TEvtRecPi0*) soff;
26533 } else {
26534 G__setgvp((long) G__PVOID);
26535 ((TEvtRecPi0*) (soff))->~G__TTEvtRecPi0();
26536 G__setgvp((long)gvp);
26537 }
26538 }
26539 G__setnull(result7);
26540 return(1 || funcname || hash || result7 || libp) ;
26541}
26542
26543// automatic assignment operator
26544static int G__RootEventData_rootcint_518_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26545{
26546 TEvtRecPi0* dest = (TEvtRecPi0*) G__getstructoffset();
26547 *dest = *(TEvtRecPi0*) libp->para[0].ref;
26548 const TEvtRecPi0& obj = *dest;
26549 result7->ref = (long) (&obj);
26550 result7->obj.i = (long) (&obj);
26551 return(1 || funcname || hash || result7 || libp) ;
26552}
26553
26554
26555/* TEvtRecEtaToGG */
26556static int G__RootEventData_rootcint_519_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26557{
26558 TEvtRecEtaToGG* p = NULL;
26559 char* gvp = (char*) G__getgvp();
26560 int n = G__getaryconstruct();
26561 if (n) {
26562 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
26563 p = new TEvtRecEtaToGG[n];
26564 } else {
26565 p = new((void*) gvp) TEvtRecEtaToGG[n];
26566 }
26567 } else {
26568 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
26569 p = new TEvtRecEtaToGG;
26570 } else {
26571 p = new((void*) gvp) TEvtRecEtaToGG;
26572 }
26573 }
26574 result7->obj.i = (long) p;
26575 result7->ref = (long) p;
26576 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG));
26577 return(1 || funcname || hash || result7 || libp) ;
26578}
26579
26580static int G__RootEventData_rootcint_519_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26581{
26582 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->unconMass());
26583 return(1 || funcname || hash || result7 || libp) ;
26584}
26585
26586static int G__RootEventData_rootcint_519_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26587{
26588 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->chisq());
26589 return(1 || funcname || hash || result7 || libp) ;
26590}
26591
26592static int G__RootEventData_rootcint_519_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26593{
26594 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiPxfit());
26595 return(1 || funcname || hash || result7 || libp) ;
26596}
26597
26598static int G__RootEventData_rootcint_519_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26599{
26600 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiPyfit());
26601 return(1 || funcname || hash || result7 || libp) ;
26602}
26603
26604static int G__RootEventData_rootcint_519_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26605{
26606 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiPzfit());
26607 return(1 || funcname || hash || result7 || libp) ;
26608}
26609
26610static int G__RootEventData_rootcint_519_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26611{
26612 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiPefit());
26613 return(1 || funcname || hash || result7 || libp) ;
26614}
26615
26616static int G__RootEventData_rootcint_519_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26617{
26618 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->loPxfit());
26619 return(1 || funcname || hash || result7 || libp) ;
26620}
26621
26622static int G__RootEventData_rootcint_519_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26623{
26624 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->loPyfit());
26625 return(1 || funcname || hash || result7 || libp) ;
26626}
26627
26628static int G__RootEventData_rootcint_519_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26629{
26630 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->loPzfit());
26631 return(1 || funcname || hash || result7 || libp) ;
26632}
26633
26634static int G__RootEventData_rootcint_519_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26635{
26636 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->loPefit());
26637 return(1 || funcname || hash || result7 || libp) ;
26638}
26639
26640static int G__RootEventData_rootcint_519_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26641{
26642 G__letint(result7, 105, (long) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiEnGamma());
26643 return(1 || funcname || hash || result7 || libp) ;
26644}
26645
26646static int G__RootEventData_rootcint_519_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26647{
26648 G__letint(result7, 105, (long) ((const TEvtRecEtaToGG*) G__getstructoffset())->loEnGamma());
26649 return(1 || funcname || hash || result7 || libp) ;
26650}
26651
26652static int G__RootEventData_rootcint_519_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26653{
26654 ((TEvtRecEtaToGG*) G__getstructoffset())->setUnconMass((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_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26660{
26661 ((TEvtRecEtaToGG*) G__getstructoffset())->setChisq((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_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26667{
26668 ((TEvtRecEtaToGG*) G__getstructoffset())->setHiPxfit((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_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26674{
26675 ((TEvtRecEtaToGG*) G__getstructoffset())->setHiPyfit((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_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26681{
26682 ((TEvtRecEtaToGG*) G__getstructoffset())->setHiPzfit((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_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26688{
26689 ((TEvtRecEtaToGG*) G__getstructoffset())->setHiPefit((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_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26695{
26696 ((TEvtRecEtaToGG*) G__getstructoffset())->setLoPxfit((Double_t) G__double(libp->para[0]));
26697 G__setnull(result7);
26698 return(1 || funcname || hash || result7 || libp) ;
26699}
26700
26701static int G__RootEventData_rootcint_519_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26702{
26703 ((TEvtRecEtaToGG*) G__getstructoffset())->setLoPyfit((Double_t) G__double(libp->para[0]));
26704 G__setnull(result7);
26705 return(1 || funcname || hash || result7 || libp) ;
26706}
26707
26708static int G__RootEventData_rootcint_519_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26709{
26710 ((TEvtRecEtaToGG*) G__getstructoffset())->setLoPzfit((Double_t) G__double(libp->para[0]));
26711 G__setnull(result7);
26712 return(1 || funcname || hash || result7 || libp) ;
26713}
26714
26715static int G__RootEventData_rootcint_519_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26716{
26717 ((TEvtRecEtaToGG*) G__getstructoffset())->setLoPefit((Double_t) G__double(libp->para[0]));
26718 G__setnull(result7);
26719 return(1 || funcname || hash || result7 || libp) ;
26720}
26721
26722static int G__RootEventData_rootcint_519_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26723{
26724 ((TEvtRecEtaToGG*) G__getstructoffset())->setHiEnGamma((Int_t) G__int(libp->para[0]));
26725 G__setnull(result7);
26726 return(1 || funcname || hash || result7 || libp) ;
26727}
26728
26729static int G__RootEventData_rootcint_519_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26730{
26731 ((TEvtRecEtaToGG*) G__getstructoffset())->setLoEnGamma((Int_t) G__int(libp->para[0]));
26732 G__setnull(result7);
26733 return(1 || funcname || hash || result7 || libp) ;
26734}
26735
26736static int G__RootEventData_rootcint_519_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26737{
26738 G__letint(result7, 85, (long) TEvtRecEtaToGG::Class());
26739 return(1 || funcname || hash || result7 || libp) ;
26740}
26741
26742static int G__RootEventData_rootcint_519_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26743{
26744 G__letint(result7, 67, (long) TEvtRecEtaToGG::Class_Name());
26745 return(1 || funcname || hash || result7 || libp) ;
26746}
26747
26748static int G__RootEventData_rootcint_519_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26749{
26750 G__letint(result7, 115, (long) TEvtRecEtaToGG::Class_Version());
26751 return(1 || funcname || hash || result7 || libp) ;
26752}
26753
26754static int G__RootEventData_rootcint_519_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26755{
26756 TEvtRecEtaToGG::Dictionary();
26757 G__setnull(result7);
26758 return(1 || funcname || hash || result7 || libp) ;
26759}
26760
26761static int G__RootEventData_rootcint_519_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26762{
26763 ((TEvtRecEtaToGG*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
26764 G__setnull(result7);
26765 return(1 || funcname || hash || result7 || libp) ;
26766}
26767
26768static int G__RootEventData_rootcint_519_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26769{
26770 G__letint(result7, 67, (long) TEvtRecEtaToGG::DeclFileName());
26771 return(1 || funcname || hash || result7 || libp) ;
26772}
26773
26774static int G__RootEventData_rootcint_519_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26775{
26776 G__letint(result7, 105, (long) TEvtRecEtaToGG::ImplFileLine());
26777 return(1 || funcname || hash || result7 || libp) ;
26778}
26779
26780static int G__RootEventData_rootcint_519_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26781{
26782 G__letint(result7, 67, (long) TEvtRecEtaToGG::ImplFileName());
26783 return(1 || funcname || hash || result7 || libp) ;
26784}
26785
26786static int G__RootEventData_rootcint_519_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26787{
26788 G__letint(result7, 105, (long) TEvtRecEtaToGG::DeclFileLine());
26789 return(1 || funcname || hash || result7 || libp) ;
26790}
26791
26792// automatic copy constructor
26793static int G__RootEventData_rootcint_519_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26794
26795{
26796 TEvtRecEtaToGG* p;
26797 void* tmp = (void*) G__int(libp->para[0]);
26798 p = new TEvtRecEtaToGG(*(TEvtRecEtaToGG*) tmp);
26799 result7->obj.i = (long) p;
26800 result7->ref = (long) p;
26801 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG));
26802 return(1 || funcname || hash || result7 || libp) ;
26803}
26804
26805// automatic destructor
26806typedef TEvtRecEtaToGG G__TTEvtRecEtaToGG;
26807static int G__RootEventData_rootcint_519_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26808{
26809 char* gvp = (char*) G__getgvp();
26810 long soff = G__getstructoffset();
26811 int n = G__getaryconstruct();
26812 //
26813 //has_a_delete: 1
26814 //has_own_delete1arg: 0
26815 //has_own_delete2arg: 0
26816 //
26817 if (!soff) {
26818 return(1);
26819 }
26820 if (n) {
26821 if (gvp == (char*)G__PVOID) {
26822 delete[] (TEvtRecEtaToGG*) soff;
26823 } else {
26824 G__setgvp((long) G__PVOID);
26825 for (int i = n - 1; i >= 0; --i) {
26826 ((TEvtRecEtaToGG*) (soff+(sizeof(TEvtRecEtaToGG)*i)))->~G__TTEvtRecEtaToGG();
26827 }
26828 G__setgvp((long)gvp);
26829 }
26830 } else {
26831 if (gvp == (char*)G__PVOID) {
26832 delete (TEvtRecEtaToGG*) soff;
26833 } else {
26834 G__setgvp((long) G__PVOID);
26835 ((TEvtRecEtaToGG*) (soff))->~G__TTEvtRecEtaToGG();
26836 G__setgvp((long)gvp);
26837 }
26838 }
26839 G__setnull(result7);
26840 return(1 || funcname || hash || result7 || libp) ;
26841}
26842
26843// automatic assignment operator
26844static int G__RootEventData_rootcint_519_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26845{
26846 TEvtRecEtaToGG* dest = (TEvtRecEtaToGG*) G__getstructoffset();
26847 *dest = *(TEvtRecEtaToGG*) libp->para[0].ref;
26848 const TEvtRecEtaToGG& obj = *dest;
26849 result7->ref = (long) (&obj);
26850 result7->obj.i = (long) (&obj);
26851 return(1 || funcname || hash || result7 || libp) ;
26852}
26853
26854
26855/* TEvtRecDTag */
26856static int G__RootEventData_rootcint_520_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26857{
26858 TEvtRecDTag* p = NULL;
26859 char* gvp = (char*) G__getgvp();
26860 int n = G__getaryconstruct();
26861 if (n) {
26862 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
26863 p = new TEvtRecDTag[n];
26864 } else {
26865 p = new((void*) gvp) TEvtRecDTag[n];
26866 }
26867 } else {
26868 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
26869 p = new TEvtRecDTag;
26870 } else {
26871 p = new((void*) gvp) TEvtRecDTag;
26872 }
26873 }
26874 result7->obj.i = (long) p;
26875 result7->ref = (long) p;
26876 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag));
26877 return(1 || funcname || hash || result7 || libp) ;
26878}
26879
26880static int G__RootEventData_rootcint_520_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26881{
26882 G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->decayMode());
26883 return(1 || funcname || hash || result7 || libp) ;
26884}
26885
26886static int G__RootEventData_rootcint_520_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26887{
26888 G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->type());
26889 return(1 || funcname || hash || result7 || libp) ;
26890}
26891
26892static int G__RootEventData_rootcint_520_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26893{
26894 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->beamE());
26895 return(1 || funcname || hash || result7 || libp) ;
26896}
26897
26898static int G__RootEventData_rootcint_520_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26899{
26900 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->mass());
26901 return(1 || funcname || hash || result7 || libp) ;
26902}
26903
26904static int G__RootEventData_rootcint_520_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26905{
26906 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->mBC());
26907 return(1 || funcname || hash || result7 || libp) ;
26908}
26909
26910static int G__RootEventData_rootcint_520_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26911{
26912 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->deltaE());
26913 return(1 || funcname || hash || result7 || libp) ;
26914}
26915
26916static int G__RootEventData_rootcint_520_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26917{
26918 G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->charge());
26919 return(1 || funcname || hash || result7 || libp) ;
26920}
26921
26922static int G__RootEventData_rootcint_520_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26923{
26924 G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->charm());
26925 return(1 || funcname || hash || result7 || libp) ;
26926}
26927
26928static int G__RootEventData_rootcint_520_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26929{
26930 G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->numOfChildren());
26931 return(1 || funcname || hash || result7 || libp) ;
26932}
26933
26934static int G__RootEventData_rootcint_520_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26935{
26936 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->px());
26937 return(1 || funcname || hash || result7 || libp) ;
26938}
26939
26940static int G__RootEventData_rootcint_520_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26941{
26942 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->py());
26943 return(1 || funcname || hash || result7 || libp) ;
26944}
26945
26946static int G__RootEventData_rootcint_520_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26947{
26948 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->pz());
26949 return(1 || funcname || hash || result7 || libp) ;
26950}
26951
26952static int G__RootEventData_rootcint_520_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26953{
26954 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->pe());
26955 return(1 || funcname || hash || result7 || libp) ;
26956}
26957
26958static int G__RootEventData_rootcint_520_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26959{
26960 {
26961 const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->tracks();
26962 result7->ref = (long) (&obj);
26963 result7->obj.i = (long) (&obj);
26964 }
26965 return(1 || funcname || hash || result7 || libp) ;
26966}
26967
26968static int G__RootEventData_rootcint_520_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26969{
26970 {
26971 const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->showers();
26972 result7->ref = (long) (&obj);
26973 result7->obj.i = (long) (&obj);
26974 }
26975 return(1 || funcname || hash || result7 || libp) ;
26976}
26977
26978static int G__RootEventData_rootcint_520_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26979{
26980 {
26981 const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->otherTracks();
26982 result7->ref = (long) (&obj);
26983 result7->obj.i = (long) (&obj);
26984 }
26985 return(1 || funcname || hash || result7 || libp) ;
26986}
26987
26988static int G__RootEventData_rootcint_520_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26989{
26990 {
26991 const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->otherShowers();
26992 result7->ref = (long) (&obj);
26993 result7->obj.i = (long) (&obj);
26994 }
26995 return(1 || funcname || hash || result7 || libp) ;
26996}
26997
26998static int G__RootEventData_rootcint_520_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26999{
27000 {
27001 const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->pionId();
27002 result7->ref = (long) (&obj);
27003 result7->obj.i = (long) (&obj);
27004 }
27005 return(1 || funcname || hash || result7 || libp) ;
27006}
27007
27008static int G__RootEventData_rootcint_520_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27009{
27010 {
27011 const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->kaonId();
27012 result7->ref = (long) (&obj);
27013 result7->obj.i = (long) (&obj);
27014 }
27015 return(1 || funcname || hash || result7 || libp) ;
27016}
27017
27018static int G__RootEventData_rootcint_520_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27019{
27020 ((TEvtRecDTag*) G__getstructoffset())->setdecayMode((Int_t) G__int(libp->para[0]));
27021 G__setnull(result7);
27022 return(1 || funcname || hash || result7 || libp) ;
27023}
27024
27025static int G__RootEventData_rootcint_520_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27026{
27027 ((TEvtRecDTag*) G__getstructoffset())->settype((Int_t) G__int(libp->para[0]));
27028 G__setnull(result7);
27029 return(1 || funcname || hash || result7 || libp) ;
27030}
27031
27032static int G__RootEventData_rootcint_520_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27033{
27034 ((TEvtRecDTag*) G__getstructoffset())->setbeamE((Double_t) G__double(libp->para[0]));
27035 G__setnull(result7);
27036 return(1 || funcname || hash || result7 || libp) ;
27037}
27038
27039static int G__RootEventData_rootcint_520_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27040{
27041 ((TEvtRecDTag*) G__getstructoffset())->setmass((Double_t) G__double(libp->para[0]));
27042 G__setnull(result7);
27043 return(1 || funcname || hash || result7 || libp) ;
27044}
27045
27046static int G__RootEventData_rootcint_520_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27047{
27048 ((TEvtRecDTag*) G__getstructoffset())->setmBC((Double_t) G__double(libp->para[0]));
27049 G__setnull(result7);
27050 return(1 || funcname || hash || result7 || libp) ;
27051}
27052
27053static int G__RootEventData_rootcint_520_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27054{
27055 ((TEvtRecDTag*) G__getstructoffset())->setdeltaE((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_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27061{
27062 ((TEvtRecDTag*) G__getstructoffset())->setcharge((Int_t) G__int(libp->para[0]));
27063 G__setnull(result7);
27064 return(1 || funcname || hash || result7 || libp) ;
27065}
27066
27067static int G__RootEventData_rootcint_520_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27068{
27069 ((TEvtRecDTag*) G__getstructoffset())->setcharm((Int_t) G__int(libp->para[0]));
27070 G__setnull(result7);
27071 return(1 || funcname || hash || result7 || libp) ;
27072}
27073
27074static int G__RootEventData_rootcint_520_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27075{
27076 ((TEvtRecDTag*) G__getstructoffset())->setnumOfChildren((Int_t) G__int(libp->para[0]));
27077 G__setnull(result7);
27078 return(1 || funcname || hash || result7 || libp) ;
27079}
27080
27081static int G__RootEventData_rootcint_520_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27082{
27083 ((TEvtRecDTag*) G__getstructoffset())->setpx((Double_t) G__double(libp->para[0]));
27084 G__setnull(result7);
27085 return(1 || funcname || hash || result7 || libp) ;
27086}
27087
27088static int G__RootEventData_rootcint_520_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27089{
27090 ((TEvtRecDTag*) G__getstructoffset())->setpy((Double_t) G__double(libp->para[0]));
27091 G__setnull(result7);
27092 return(1 || funcname || hash || result7 || libp) ;
27093}
27094
27095static int G__RootEventData_rootcint_520_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27096{
27097 ((TEvtRecDTag*) G__getstructoffset())->setpz((Double_t) G__double(libp->para[0]));
27098 G__setnull(result7);
27099 return(1 || funcname || hash || result7 || libp) ;
27100}
27101
27102static int G__RootEventData_rootcint_520_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27103{
27104 ((TEvtRecDTag*) G__getstructoffset())->setpe((Double_t) G__double(libp->para[0]));
27105 G__setnull(result7);
27106 return(1 || funcname || hash || result7 || libp) ;
27107}
27108
27109static int G__RootEventData_rootcint_520_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27110{
27111 ((TEvtRecDTag*) G__getstructoffset())->setTracks(*(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_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27117{
27118 ((TEvtRecDTag*) G__getstructoffset())->setShowers(*(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_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27124{
27125 ((TEvtRecDTag*) G__getstructoffset())->setOtherTracks(*(vector<Int_t>*) libp->para[0].ref);
27126 G__setnull(result7);
27127 return(1 || funcname || hash || result7 || libp) ;
27128}
27129
27130static int G__RootEventData_rootcint_520_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27131{
27132 ((TEvtRecDTag*) G__getstructoffset())->setOtherShowers(*(vector<Int_t>*) libp->para[0].ref);
27133 G__setnull(result7);
27134 return(1 || funcname || hash || result7 || libp) ;
27135}
27136
27137static int G__RootEventData_rootcint_520_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27138{
27139 ((TEvtRecDTag*) G__getstructoffset())->setPionId(*(vector<Int_t>*) libp->para[0].ref);
27140 G__setnull(result7);
27141 return(1 || funcname || hash || result7 || libp) ;
27142}
27143
27144static int G__RootEventData_rootcint_520_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27145{
27146 ((TEvtRecDTag*) G__getstructoffset())->setKaonId(*(vector<Int_t>*) libp->para[0].ref);
27147 G__setnull(result7);
27148 return(1 || funcname || hash || result7 || libp) ;
27149}
27150
27151static int G__RootEventData_rootcint_520_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27152{
27153 ((TEvtRecDTag*) G__getstructoffset())->addTrack((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_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27159{
27160 ((TEvtRecDTag*) G__getstructoffset())->addShower((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_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27166{
27167 ((TEvtRecDTag*) G__getstructoffset())->addOtherTrack((Int_t) G__int(libp->para[0]));
27168 G__setnull(result7);
27169 return(1 || funcname || hash || result7 || libp) ;
27170}
27171
27172static int G__RootEventData_rootcint_520_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27173{
27174 ((TEvtRecDTag*) G__getstructoffset())->addOtherShower((Int_t) G__int(libp->para[0]));
27175 G__setnull(result7);
27176 return(1 || funcname || hash || result7 || libp) ;
27177}
27178
27179static int G__RootEventData_rootcint_520_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27180{
27181 ((TEvtRecDTag*) G__getstructoffset())->addPionId((Int_t) G__int(libp->para[0]));
27182 G__setnull(result7);
27183 return(1 || funcname || hash || result7 || libp) ;
27184}
27185
27186static int G__RootEventData_rootcint_520_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27187{
27188 ((TEvtRecDTag*) G__getstructoffset())->addKaonId((Int_t) G__int(libp->para[0]));
27189 G__setnull(result7);
27190 return(1 || funcname || hash || result7 || libp) ;
27191}
27192
27193static int G__RootEventData_rootcint_520_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27194{
27195 G__letint(result7, 85, (long) TEvtRecDTag::Class());
27196 return(1 || funcname || hash || result7 || libp) ;
27197}
27198
27199static int G__RootEventData_rootcint_520_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27200{
27201 G__letint(result7, 67, (long) TEvtRecDTag::Class_Name());
27202 return(1 || funcname || hash || result7 || libp) ;
27203}
27204
27205static int G__RootEventData_rootcint_520_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27206{
27207 G__letint(result7, 115, (long) TEvtRecDTag::Class_Version());
27208 return(1 || funcname || hash || result7 || libp) ;
27209}
27210
27211static int G__RootEventData_rootcint_520_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27212{
27213 TEvtRecDTag::Dictionary();
27214 G__setnull(result7);
27215 return(1 || funcname || hash || result7 || libp) ;
27216}
27217
27218static int G__RootEventData_rootcint_520_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27219{
27220 ((TEvtRecDTag*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
27221 G__setnull(result7);
27222 return(1 || funcname || hash || result7 || libp) ;
27223}
27224
27225static int G__RootEventData_rootcint_520_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27226{
27227 G__letint(result7, 67, (long) TEvtRecDTag::DeclFileName());
27228 return(1 || funcname || hash || result7 || libp) ;
27229}
27230
27231static int G__RootEventData_rootcint_520_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27232{
27233 G__letint(result7, 105, (long) TEvtRecDTag::ImplFileLine());
27234 return(1 || funcname || hash || result7 || libp) ;
27235}
27236
27237static int G__RootEventData_rootcint_520_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27238{
27239 G__letint(result7, 67, (long) TEvtRecDTag::ImplFileName());
27240 return(1 || funcname || hash || result7 || libp) ;
27241}
27242
27243static int G__RootEventData_rootcint_520_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27244{
27245 G__letint(result7, 105, (long) TEvtRecDTag::DeclFileLine());
27246 return(1 || funcname || hash || result7 || libp) ;
27247}
27248
27249// automatic copy constructor
27250static int G__RootEventData_rootcint_520_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27251
27252{
27253 TEvtRecDTag* p;
27254 void* tmp = (void*) G__int(libp->para[0]);
27255 p = new TEvtRecDTag(*(TEvtRecDTag*) tmp);
27256 result7->obj.i = (long) p;
27257 result7->ref = (long) p;
27258 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag));
27259 return(1 || funcname || hash || result7 || libp) ;
27260}
27261
27262// automatic destructor
27263typedef TEvtRecDTag G__TTEvtRecDTag;
27264static int G__RootEventData_rootcint_520_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27265{
27266 char* gvp = (char*) G__getgvp();
27267 long soff = G__getstructoffset();
27268 int n = G__getaryconstruct();
27269 //
27270 //has_a_delete: 1
27271 //has_own_delete1arg: 0
27272 //has_own_delete2arg: 0
27273 //
27274 if (!soff) {
27275 return(1);
27276 }
27277 if (n) {
27278 if (gvp == (char*)G__PVOID) {
27279 delete[] (TEvtRecDTag*) soff;
27280 } else {
27281 G__setgvp((long) G__PVOID);
27282 for (int i = n - 1; i >= 0; --i) {
27283 ((TEvtRecDTag*) (soff+(sizeof(TEvtRecDTag)*i)))->~G__TTEvtRecDTag();
27284 }
27285 G__setgvp((long)gvp);
27286 }
27287 } else {
27288 if (gvp == (char*)G__PVOID) {
27289 delete (TEvtRecDTag*) soff;
27290 } else {
27291 G__setgvp((long) G__PVOID);
27292 ((TEvtRecDTag*) (soff))->~G__TTEvtRecDTag();
27293 G__setgvp((long)gvp);
27294 }
27295 }
27296 G__setnull(result7);
27297 return(1 || funcname || hash || result7 || libp) ;
27298}
27299
27300// automatic assignment operator
27301static int G__RootEventData_rootcint_520_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27302{
27303 TEvtRecDTag* dest = (TEvtRecDTag*) G__getstructoffset();
27304 *dest = *(TEvtRecDTag*) libp->para[0].ref;
27305 const TEvtRecDTag& obj = *dest;
27306 result7->ref = (long) (&obj);
27307 result7->obj.i = (long) (&obj);
27308 return(1 || funcname || hash || result7 || libp) ;
27309}
27310
27311
27312/* TEvtRecObject */
27313static int G__RootEventData_rootcint_521_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27314{
27315 TEvtRecObject* p = NULL;
27316 char* gvp = (char*) G__getgvp();
27317 int n = G__getaryconstruct();
27318 if (n) {
27319 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
27320 p = new TEvtRecObject[n];
27321 } else {
27322 p = new((void*) gvp) TEvtRecObject[n];
27323 }
27324 } else {
27325 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
27326 p = new TEvtRecObject;
27327 } else {
27328 p = new((void*) gvp) TEvtRecObject;
27329 }
27330 }
27331 result7->obj.i = (long) p;
27332 result7->ref = (long) p;
27333 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject));
27334 return(1 || funcname || hash || result7 || libp) ;
27335}
27336
27337static int G__RootEventData_rootcint_521_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27338{
27339 ((TEvtRecObject*) G__getstructoffset())->initialize();
27340 G__setnull(result7);
27341 return(1 || funcname || hash || result7 || libp) ;
27342}
27343
27344static int G__RootEventData_rootcint_521_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27345{
27346 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecEvent());
27347 return(1 || funcname || hash || result7 || libp) ;
27348}
27349
27350static int G__RootEventData_rootcint_521_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27351{
27352 ((TEvtRecObject*) G__getstructoffset())->setEvtRecEvent((TEvtRecEvent*) G__int(libp->para[0]));
27353 G__setnull(result7);
27354 return(1 || funcname || hash || result7 || libp) ;
27355}
27356
27357static int G__RootEventData_rootcint_521_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27358{
27359 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecTrackCol());
27360 return(1 || funcname || hash || result7 || libp) ;
27361}
27362
27363static int G__RootEventData_rootcint_521_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27364{
27365 ((TEvtRecObject*) G__getstructoffset())->addEvtRecTrack((TEvtRecTrack*) G__int(libp->para[0]));
27366 G__setnull(result7);
27367 return(1 || funcname || hash || result7 || libp) ;
27368}
27369
27370static int G__RootEventData_rootcint_521_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27371{
27372 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecTrack((Int_t) G__int(libp->para[0])));
27373 return(1 || funcname || hash || result7 || libp) ;
27374}
27375
27376static int G__RootEventData_rootcint_521_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27377{
27378 ((TEvtRecObject*) G__getstructoffset())->clearEvtRecTrackCol();
27379 G__setnull(result7);
27380 return(1 || funcname || hash || result7 || libp) ;
27381}
27382
27383static int G__RootEventData_rootcint_521_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27384{
27385 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecPrimaryVertex());
27386 return(1 || funcname || hash || result7 || libp) ;
27387}
27388
27389static int G__RootEventData_rootcint_521_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27390{
27391 ((TEvtRecObject*) G__getstructoffset())->setEvtRecPrimaryVertex((TEvtRecPrimaryVertex*) G__int(libp->para[0]));
27392 G__setnull(result7);
27393 return(1 || funcname || hash || result7 || libp) ;
27394}
27395
27396static int G__RootEventData_rootcint_521_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27397{
27398 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecVeeVertexCol());
27399 return(1 || funcname || hash || result7 || libp) ;
27400}
27401
27402static int G__RootEventData_rootcint_521_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27403{
27404 ((TEvtRecObject*) G__getstructoffset())->addEvtRecVeeVertex((TEvtRecVeeVertex*) G__int(libp->para[0]));
27405 G__setnull(result7);
27406 return(1 || funcname || hash || result7 || libp) ;
27407}
27408
27409static int G__RootEventData_rootcint_521_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27410{
27411 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecVeeVertex((Int_t) G__int(libp->para[0])));
27412 return(1 || funcname || hash || result7 || libp) ;
27413}
27414
27415static int G__RootEventData_rootcint_521_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27416{
27417 ((TEvtRecObject*) G__getstructoffset())->clearEvtRecVeeVertexCol();
27418 G__setnull(result7);
27419 return(1 || funcname || hash || result7 || libp) ;
27420}
27421
27422static int G__RootEventData_rootcint_521_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27423{
27424 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecPi0Col());
27425 return(1 || funcname || hash || result7 || libp) ;
27426}
27427
27428static int G__RootEventData_rootcint_521_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27429{
27430 ((TEvtRecObject*) G__getstructoffset())->addEvtRecPi0((TEvtRecPi0*) G__int(libp->para[0]));
27431 G__setnull(result7);
27432 return(1 || funcname || hash || result7 || libp) ;
27433}
27434
27435static int G__RootEventData_rootcint_521_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27436{
27437 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecPi0((Int_t) G__int(libp->para[0])));
27438 return(1 || funcname || hash || result7 || libp) ;
27439}
27440
27441static int G__RootEventData_rootcint_521_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27442{
27443 ((TEvtRecObject*) G__getstructoffset())->clearEvtRecPi0Col();
27444 G__setnull(result7);
27445 return(1 || funcname || hash || result7 || libp) ;
27446}
27447
27448static int G__RootEventData_rootcint_521_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27449{
27450 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecEtaToGGCol());
27451 return(1 || funcname || hash || result7 || libp) ;
27452}
27453
27454static int G__RootEventData_rootcint_521_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27455{
27456 ((TEvtRecObject*) G__getstructoffset())->addEvtRecEtaToGG((TEvtRecEtaToGG*) G__int(libp->para[0]));
27457 G__setnull(result7);
27458 return(1 || funcname || hash || result7 || libp) ;
27459}
27460
27461static int G__RootEventData_rootcint_521_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27462{
27463 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecEtaToGG((Int_t) G__int(libp->para[0])));
27464 return(1 || funcname || hash || result7 || libp) ;
27465}
27466
27467static int G__RootEventData_rootcint_521_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27468{
27469 ((TEvtRecObject*) G__getstructoffset())->clearEvtRecEtaToGGCol();
27470 G__setnull(result7);
27471 return(1 || funcname || hash || result7 || libp) ;
27472}
27473
27474static int G__RootEventData_rootcint_521_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27475{
27476 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecDTagCol());
27477 return(1 || funcname || hash || result7 || libp) ;
27478}
27479
27480static int G__RootEventData_rootcint_521_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27481{
27482 ((TEvtRecObject*) G__getstructoffset())->addEvtRecDTag((TEvtRecDTag*) G__int(libp->para[0]));
27483 G__setnull(result7);
27484 return(1 || funcname || hash || result7 || libp) ;
27485}
27486
27487static int G__RootEventData_rootcint_521_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27488{
27489 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecDTag((Int_t) G__int(libp->para[0])));
27490 return(1 || funcname || hash || result7 || libp) ;
27491}
27492
27493static int G__RootEventData_rootcint_521_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27494{
27495 ((TEvtRecObject*) G__getstructoffset())->clearEvtRecDTagCol();
27496 G__setnull(result7);
27497 return(1 || funcname || hash || result7 || libp) ;
27498}
27499
27500static int G__RootEventData_rootcint_521_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27501{
27502 G__letint(result7, 85, (long) TEvtRecObject::Class());
27503 return(1 || funcname || hash || result7 || libp) ;
27504}
27505
27506static int G__RootEventData_rootcint_521_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27507{
27508 G__letint(result7, 67, (long) TEvtRecObject::Class_Name());
27509 return(1 || funcname || hash || result7 || libp) ;
27510}
27511
27512static int G__RootEventData_rootcint_521_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27513{
27514 G__letint(result7, 115, (long) TEvtRecObject::Class_Version());
27515 return(1 || funcname || hash || result7 || libp) ;
27516}
27517
27518static int G__RootEventData_rootcint_521_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27519{
27520 TEvtRecObject::Dictionary();
27521 G__setnull(result7);
27522 return(1 || funcname || hash || result7 || libp) ;
27523}
27524
27525static int G__RootEventData_rootcint_521_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27526{
27527 ((TEvtRecObject*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
27528 G__setnull(result7);
27529 return(1 || funcname || hash || result7 || libp) ;
27530}
27531
27532static int G__RootEventData_rootcint_521_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27533{
27534 G__letint(result7, 67, (long) TEvtRecObject::DeclFileName());
27535 return(1 || funcname || hash || result7 || libp) ;
27536}
27537
27538static int G__RootEventData_rootcint_521_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27539{
27540 G__letint(result7, 105, (long) TEvtRecObject::ImplFileLine());
27541 return(1 || funcname || hash || result7 || libp) ;
27542}
27543
27544static int G__RootEventData_rootcint_521_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27545{
27546 G__letint(result7, 67, (long) TEvtRecObject::ImplFileName());
27547 return(1 || funcname || hash || result7 || libp) ;
27548}
27549
27550static int G__RootEventData_rootcint_521_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27551{
27552 G__letint(result7, 105, (long) TEvtRecObject::DeclFileLine());
27553 return(1 || funcname || hash || result7 || libp) ;
27554}
27555
27556// automatic copy constructor
27557static int G__RootEventData_rootcint_521_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27558
27559{
27560 TEvtRecObject* p;
27561 void* tmp = (void*) G__int(libp->para[0]);
27562 p = new TEvtRecObject(*(TEvtRecObject*) tmp);
27563 result7->obj.i = (long) p;
27564 result7->ref = (long) p;
27565 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject));
27566 return(1 || funcname || hash || result7 || libp) ;
27567}
27568
27569// automatic destructor
27570typedef TEvtRecObject G__TTEvtRecObject;
27571static int G__RootEventData_rootcint_521_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27572{
27573 char* gvp = (char*) G__getgvp();
27574 long soff = G__getstructoffset();
27575 int n = G__getaryconstruct();
27576 //
27577 //has_a_delete: 1
27578 //has_own_delete1arg: 0
27579 //has_own_delete2arg: 0
27580 //
27581 if (!soff) {
27582 return(1);
27583 }
27584 if (n) {
27585 if (gvp == (char*)G__PVOID) {
27586 delete[] (TEvtRecObject*) soff;
27587 } else {
27588 G__setgvp((long) G__PVOID);
27589 for (int i = n - 1; i >= 0; --i) {
27590 ((TEvtRecObject*) (soff+(sizeof(TEvtRecObject)*i)))->~G__TTEvtRecObject();
27591 }
27592 G__setgvp((long)gvp);
27593 }
27594 } else {
27595 if (gvp == (char*)G__PVOID) {
27596 delete (TEvtRecObject*) soff;
27597 } else {
27598 G__setgvp((long) G__PVOID);
27599 ((TEvtRecObject*) (soff))->~G__TTEvtRecObject();
27600 G__setgvp((long)gvp);
27601 }
27602 }
27603 G__setnull(result7);
27604 return(1 || funcname || hash || result7 || libp) ;
27605}
27606
27607// automatic assignment operator
27608static int G__RootEventData_rootcint_521_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27609{
27610 TEvtRecObject* dest = (TEvtRecObject*) G__getstructoffset();
27611 *dest = *(TEvtRecObject*) libp->para[0].ref;
27612 const TEvtRecObject& obj = *dest;
27613 result7->ref = (long) (&obj);
27614 result7->obj.i = (long) (&obj);
27615 return(1 || funcname || hash || result7 || libp) ;
27616}
27617
27618
27619/* TMcHitTof */
27620static int G__RootEventData_rootcint_559_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27621{
27622 TMcHitTof* p = NULL;
27623 char* gvp = (char*) G__getgvp();
27624 int n = G__getaryconstruct();
27625 if (n) {
27626 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
27627 p = new TMcHitTof[n];
27628 } else {
27629 p = new((void*) gvp) TMcHitTof[n];
27630 }
27631 } else {
27632 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
27633 p = new TMcHitTof;
27634 } else {
27635 p = new((void*) gvp) TMcHitTof;
27636 }
27637 }
27638 result7->obj.i = (long) p;
27639 result7->ref = (long) p;
27640 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof));
27641 return(1 || funcname || hash || result7 || libp) ;
27642}
27643
27644static int G__RootEventData_rootcint_559_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27645{
27646 ((TMcHitTof*) G__getstructoffset())->SetTrackIndex((Int_t) G__int(libp->para[0]));
27647 G__setnull(result7);
27648 return(1 || funcname || hash || result7 || libp) ;
27649}
27650
27651static int G__RootEventData_rootcint_559_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27652{
27653 ((TMcHitTof*) G__getstructoffset())->SetG4Index((Int_t) G__int(libp->para[0]));
27654 G__setnull(result7);
27655 return(1 || funcname || hash || result7 || libp) ;
27656}
27657
27658static int G__RootEventData_rootcint_559_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27659{
27660 ((TMcHitTof*) G__getstructoffset())->SetPartId((Int_t) G__int(libp->para[0]));
27661 G__setnull(result7);
27662 return(1 || funcname || hash || result7 || libp) ;
27663}
27664
27665static int G__RootEventData_rootcint_559_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27666{
27667 ((TMcHitTof*) G__getstructoffset())->SetScinNb((Int_t) 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_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27673{
27674 ((TMcHitTof*) G__getstructoffset())->SetEdep((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_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27680{
27681 ((TMcHitTof*) G__getstructoffset())->SetStepL((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_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27687{
27688 ((TMcHitTof*) G__getstructoffset())->SetTrackL((Double_t) G__double(libp->para[0]));
27689 G__setnull(result7);
27690 return(1 || funcname || hash || result7 || libp) ;
27691}
27692
27693static int G__RootEventData_rootcint_559_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27694{
27695 ((TMcHitTof*) G__getstructoffset())->SetPos(*((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_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27701{
27702 ((TMcHitTof*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
27703 G__setnull(result7);
27704 return(1 || funcname || hash || result7 || libp) ;
27705}
27706
27707static int G__RootEventData_rootcint_559_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27708{
27709 ((TMcHitTof*) G__getstructoffset())->SetDeltaT((Double_t) G__double(libp->para[0]));
27710 G__setnull(result7);
27711 return(1 || funcname || hash || result7 || libp) ;
27712}
27713
27714static int G__RootEventData_rootcint_559_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27715{
27716 ((TMcHitTof*) G__getstructoffset())->SetPDirection(*((TVector3*) G__int(libp->para[0])));
27717 G__setnull(result7);
27718 return(1 || funcname || hash || result7 || libp) ;
27719}
27720
27721static int G__RootEventData_rootcint_559_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27722{
27723 ((TMcHitTof*) G__getstructoffset())->SetMomentum(*((TVector3*) G__int(libp->para[0])));
27724 G__setnull(result7);
27725 return(1 || funcname || hash || result7 || libp) ;
27726}
27727
27728static int G__RootEventData_rootcint_559_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27729{
27730 ((TMcHitTof*) G__getstructoffset())->SetCharge((Int_t) G__int(libp->para[0]));
27731 G__setnull(result7);
27732 return(1 || funcname || hash || result7 || libp) ;
27733}
27734
27735static int G__RootEventData_rootcint_559_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27736{
27737 G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetTrackIndex());
27738 return(1 || funcname || hash || result7 || libp) ;
27739}
27740
27741static int G__RootEventData_rootcint_559_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27742{
27743 G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetG4Index());
27744 return(1 || funcname || hash || result7 || libp) ;
27745}
27746
27747static int G__RootEventData_rootcint_559_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27748{
27749 G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetPartId());
27750 return(1 || funcname || hash || result7 || libp) ;
27751}
27752
27753static int G__RootEventData_rootcint_559_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27754{
27755 G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetScinNb());
27756 return(1 || funcname || hash || result7 || libp) ;
27757}
27758
27759static int G__RootEventData_rootcint_559_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27760{
27761 G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetEdep());
27762 return(1 || funcname || hash || result7 || libp) ;
27763}
27764
27765static int G__RootEventData_rootcint_559_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27766{
27767 G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetStepL());
27768 return(1 || funcname || hash || result7 || libp) ;
27769}
27770
27771static int G__RootEventData_rootcint_559_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27772{
27773 G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetTrackL());
27774 return(1 || funcname || hash || result7 || libp) ;
27775}
27776
27777static int G__RootEventData_rootcint_559_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27778{
27779 {
27780 const TVector3* pobj;
27781 const TVector3 xobj = ((const TMcHitTof*) G__getstructoffset())->GetPos();
27782 pobj = new TVector3(xobj);
27783 result7->obj.i = (long) ((void*) pobj);
27784 result7->ref = result7->obj.i;
27785 G__store_tempobject(*result7);
27786 }
27787 return(1 || funcname || hash || result7 || libp) ;
27788}
27789
27790static int G__RootEventData_rootcint_559_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27791{
27792 G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetTime());
27793 return(1 || funcname || hash || result7 || libp) ;
27794}
27795
27796static int G__RootEventData_rootcint_559_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27797{
27798 G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetDeltaT());
27799 return(1 || funcname || hash || result7 || libp) ;
27800}
27801
27802static int G__RootEventData_rootcint_559_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27803{
27804 {
27805 const TVector3* pobj;
27806 const TVector3 xobj = ((const TMcHitTof*) G__getstructoffset())->GetPDirection();
27807 pobj = new TVector3(xobj);
27808 result7->obj.i = (long) ((void*) pobj);
27809 result7->ref = result7->obj.i;
27810 G__store_tempobject(*result7);
27811 }
27812 return(1 || funcname || hash || result7 || libp) ;
27813}
27814
27815static int G__RootEventData_rootcint_559_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27816{
27817 {
27818 const TVector3* pobj;
27819 const TVector3 xobj = ((const TMcHitTof*) G__getstructoffset())->GetMomentum();
27820 pobj = new TVector3(xobj);
27821 result7->obj.i = (long) ((void*) pobj);
27822 result7->ref = result7->obj.i;
27823 G__store_tempobject(*result7);
27824 }
27825 return(1 || funcname || hash || result7 || libp) ;
27826}
27827
27828static int G__RootEventData_rootcint_559_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27829{
27830 G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetCharge());
27831 return(1 || funcname || hash || result7 || libp) ;
27832}
27833
27834static int G__RootEventData_rootcint_559_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27835{
27836 G__letint(result7, 85, (long) TMcHitTof::Class());
27837 return(1 || funcname || hash || result7 || libp) ;
27838}
27839
27840static int G__RootEventData_rootcint_559_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27841{
27842 G__letint(result7, 67, (long) TMcHitTof::Class_Name());
27843 return(1 || funcname || hash || result7 || libp) ;
27844}
27845
27846static int G__RootEventData_rootcint_559_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27847{
27848 G__letint(result7, 115, (long) TMcHitTof::Class_Version());
27849 return(1 || funcname || hash || result7 || libp) ;
27850}
27851
27852static int G__RootEventData_rootcint_559_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27853{
27854 TMcHitTof::Dictionary();
27855 G__setnull(result7);
27856 return(1 || funcname || hash || result7 || libp) ;
27857}
27858
27859static int G__RootEventData_rootcint_559_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27860{
27861 ((TMcHitTof*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
27862 G__setnull(result7);
27863 return(1 || funcname || hash || result7 || libp) ;
27864}
27865
27866static int G__RootEventData_rootcint_559_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27867{
27868 G__letint(result7, 67, (long) TMcHitTof::DeclFileName());
27869 return(1 || funcname || hash || result7 || libp) ;
27870}
27871
27872static int G__RootEventData_rootcint_559_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27873{
27874 G__letint(result7, 105, (long) TMcHitTof::ImplFileLine());
27875 return(1 || funcname || hash || result7 || libp) ;
27876}
27877
27878static int G__RootEventData_rootcint_559_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27879{
27880 G__letint(result7, 67, (long) TMcHitTof::ImplFileName());
27881 return(1 || funcname || hash || result7 || libp) ;
27882}
27883
27884static int G__RootEventData_rootcint_559_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27885{
27886 G__letint(result7, 105, (long) TMcHitTof::DeclFileLine());
27887 return(1 || funcname || hash || result7 || libp) ;
27888}
27889
27890// automatic copy constructor
27891static int G__RootEventData_rootcint_559_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27892
27893{
27894 TMcHitTof* p;
27895 void* tmp = (void*) G__int(libp->para[0]);
27896 p = new TMcHitTof(*(TMcHitTof*) tmp);
27897 result7->obj.i = (long) p;
27898 result7->ref = (long) p;
27899 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof));
27900 return(1 || funcname || hash || result7 || libp) ;
27901}
27902
27903// automatic destructor
27904typedef TMcHitTof G__TTMcHitTof;
27905static int G__RootEventData_rootcint_559_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27906{
27907 char* gvp = (char*) G__getgvp();
27908 long soff = G__getstructoffset();
27909 int n = G__getaryconstruct();
27910 //
27911 //has_a_delete: 1
27912 //has_own_delete1arg: 0
27913 //has_own_delete2arg: 0
27914 //
27915 if (!soff) {
27916 return(1);
27917 }
27918 if (n) {
27919 if (gvp == (char*)G__PVOID) {
27920 delete[] (TMcHitTof*) soff;
27921 } else {
27922 G__setgvp((long) G__PVOID);
27923 for (int i = n - 1; i >= 0; --i) {
27924 ((TMcHitTof*) (soff+(sizeof(TMcHitTof)*i)))->~G__TTMcHitTof();
27925 }
27926 G__setgvp((long)gvp);
27927 }
27928 } else {
27929 if (gvp == (char*)G__PVOID) {
27930 delete (TMcHitTof*) soff;
27931 } else {
27932 G__setgvp((long) G__PVOID);
27933 ((TMcHitTof*) (soff))->~G__TTMcHitTof();
27934 G__setgvp((long)gvp);
27935 }
27936 }
27937 G__setnull(result7);
27938 return(1 || funcname || hash || result7 || libp) ;
27939}
27940
27941// automatic assignment operator
27942static int G__RootEventData_rootcint_559_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27943{
27944 TMcHitTof* dest = (TMcHitTof*) G__getstructoffset();
27945 *dest = *(TMcHitTof*) libp->para[0].ref;
27946 const TMcHitTof& obj = *dest;
27947 result7->ref = (long) (&obj);
27948 result7->obj.i = (long) (&obj);
27949 return(1 || funcname || hash || result7 || libp) ;
27950}
27951
27952
27953/* TMcHitMdc */
27954static int G__RootEventData_rootcint_560_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27955{
27956 TMcHitMdc* p = NULL;
27957 char* gvp = (char*) G__getgvp();
27958 int n = G__getaryconstruct();
27959 if (n) {
27960 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
27961 p = new TMcHitMdc[n];
27962 } else {
27963 p = new((void*) gvp) TMcHitMdc[n];
27964 }
27965 } else {
27966 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
27967 p = new TMcHitMdc;
27968 } else {
27969 p = new((void*) gvp) TMcHitMdc;
27970 }
27971 }
27972 result7->obj.i = (long) p;
27973 result7->ref = (long) p;
27974 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc));
27975 return(1 || funcname || hash || result7 || libp) ;
27976}
27977
27978static int G__RootEventData_rootcint_560_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27979{
27980 ((TMcHitMdc*) G__getstructoffset())->SetTrackID((Int_t) 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_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27986{
27987 ((TMcHitMdc*) G__getstructoffset())->SetLayerNo((Int_t) G__int(libp->para[0]));
27988 G__setnull(result7);
27989 return(1 || funcname || hash || result7 || libp) ;
27990}
27991
27992static int G__RootEventData_rootcint_560_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27993{
27994 ((TMcHitMdc*) G__getstructoffset())->SetCellNo((Int_t) G__int(libp->para[0]));
27995 G__setnull(result7);
27996 return(1 || funcname || hash || result7 || libp) ;
27997}
27998
27999static int G__RootEventData_rootcint_560_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28000{
28001 ((TMcHitMdc*) G__getstructoffset())->SetEdep((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_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28007{
28008 ((TMcHitMdc*) G__getstructoffset())->SetPos(*((TVector3*) G__int(libp->para[0])));
28009 G__setnull(result7);
28010 return(1 || funcname || hash || result7 || libp) ;
28011}
28012
28013static int G__RootEventData_rootcint_560_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28014{
28015 ((TMcHitMdc*) G__getstructoffset())->SetDriftD((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_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28021{
28022 ((TMcHitMdc*) G__getstructoffset())->SetDriftT((Double_t) G__double(libp->para[0]));
28023 G__setnull(result7);
28024 return(1 || funcname || hash || result7 || libp) ;
28025}
28026
28027static int G__RootEventData_rootcint_560_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28028{
28029 ((TMcHitMdc*) G__getstructoffset())->SetGlobalT((Double_t) G__double(libp->para[0]));
28030 G__setnull(result7);
28031 return(1 || funcname || hash || result7 || libp) ;
28032}
28033
28034static int G__RootEventData_rootcint_560_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28035{
28036 ((TMcHitMdc*) G__getstructoffset())->SetTheta((Double_t) G__double(libp->para[0]));
28037 G__setnull(result7);
28038 return(1 || funcname || hash || result7 || libp) ;
28039}
28040
28041static int G__RootEventData_rootcint_560_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28042{
28043 ((TMcHitMdc*) G__getstructoffset())->SetEnterAngle((Double_t) G__double(libp->para[0]));
28044 G__setnull(result7);
28045 return(1 || funcname || hash || result7 || libp) ;
28046}
28047
28048static int G__RootEventData_rootcint_560_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28049{
28050 ((TMcHitMdc*) G__getstructoffset())->SetPosFlag((Int_t) G__int(libp->para[0]));
28051 G__setnull(result7);
28052 return(1 || funcname || hash || result7 || libp) ;
28053}
28054
28055static int G__RootEventData_rootcint_560_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28056{
28057 G__letint(result7, 105, (long) ((const TMcHitMdc*) G__getstructoffset())->GetTrackID());
28058 return(1 || funcname || hash || result7 || libp) ;
28059}
28060
28061static int G__RootEventData_rootcint_560_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28062{
28063 G__letint(result7, 105, (long) ((const TMcHitMdc*) G__getstructoffset())->GetLayerNo());
28064 return(1 || funcname || hash || result7 || libp) ;
28065}
28066
28067static int G__RootEventData_rootcint_560_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28068{
28069 G__letint(result7, 105, (long) ((const TMcHitMdc*) G__getstructoffset())->GetCellNo());
28070 return(1 || funcname || hash || result7 || libp) ;
28071}
28072
28073static int G__RootEventData_rootcint_560_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28074{
28075 G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetEdep());
28076 return(1 || funcname || hash || result7 || libp) ;
28077}
28078
28079static int G__RootEventData_rootcint_560_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28080{
28081 {
28082 const TVector3* pobj;
28083 const TVector3 xobj = ((const TMcHitMdc*) G__getstructoffset())->GetPos();
28084 pobj = new TVector3(xobj);
28085 result7->obj.i = (long) ((void*) pobj);
28086 result7->ref = result7->obj.i;
28087 G__store_tempobject(*result7);
28088 }
28089 return(1 || funcname || hash || result7 || libp) ;
28090}
28091
28092static int G__RootEventData_rootcint_560_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28093{
28094 G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetDriftD());
28095 return(1 || funcname || hash || result7 || libp) ;
28096}
28097
28098static int G__RootEventData_rootcint_560_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28099{
28100 G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetDriftT());
28101 return(1 || funcname || hash || result7 || libp) ;
28102}
28103
28104static int G__RootEventData_rootcint_560_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28105{
28106 G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetGlobalT());
28107 return(1 || funcname || hash || result7 || libp) ;
28108}
28109
28110static int G__RootEventData_rootcint_560_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28111{
28112 G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetTheta());
28113 return(1 || funcname || hash || result7 || libp) ;
28114}
28115
28116static int G__RootEventData_rootcint_560_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28117{
28118 G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetEnterAngle());
28119 return(1 || funcname || hash || result7 || libp) ;
28120}
28121
28122static int G__RootEventData_rootcint_560_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28123{
28124 G__letint(result7, 105, (long) ((const TMcHitMdc*) G__getstructoffset())->GetPosFlag());
28125 return(1 || funcname || hash || result7 || libp) ;
28126}
28127
28128static int G__RootEventData_rootcint_560_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28129{
28130 G__letint(result7, 85, (long) TMcHitMdc::Class());
28131 return(1 || funcname || hash || result7 || libp) ;
28132}
28133
28134static int G__RootEventData_rootcint_560_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28135{
28136 G__letint(result7, 67, (long) TMcHitMdc::Class_Name());
28137 return(1 || funcname || hash || result7 || libp) ;
28138}
28139
28140static int G__RootEventData_rootcint_560_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28141{
28142 G__letint(result7, 115, (long) TMcHitMdc::Class_Version());
28143 return(1 || funcname || hash || result7 || libp) ;
28144}
28145
28146static int G__RootEventData_rootcint_560_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28147{
28148 TMcHitMdc::Dictionary();
28149 G__setnull(result7);
28150 return(1 || funcname || hash || result7 || libp) ;
28151}
28152
28153static int G__RootEventData_rootcint_560_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28154{
28155 ((TMcHitMdc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
28156 G__setnull(result7);
28157 return(1 || funcname || hash || result7 || libp) ;
28158}
28159
28160static int G__RootEventData_rootcint_560_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28161{
28162 G__letint(result7, 67, (long) TMcHitMdc::DeclFileName());
28163 return(1 || funcname || hash || result7 || libp) ;
28164}
28165
28166static int G__RootEventData_rootcint_560_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28167{
28168 G__letint(result7, 105, (long) TMcHitMdc::ImplFileLine());
28169 return(1 || funcname || hash || result7 || libp) ;
28170}
28171
28172static int G__RootEventData_rootcint_560_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28173{
28174 G__letint(result7, 67, (long) TMcHitMdc::ImplFileName());
28175 return(1 || funcname || hash || result7 || libp) ;
28176}
28177
28178static int G__RootEventData_rootcint_560_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28179{
28180 G__letint(result7, 105, (long) TMcHitMdc::DeclFileLine());
28181 return(1 || funcname || hash || result7 || libp) ;
28182}
28183
28184// automatic copy constructor
28185static int G__RootEventData_rootcint_560_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28186
28187{
28188 TMcHitMdc* p;
28189 void* tmp = (void*) G__int(libp->para[0]);
28190 p = new TMcHitMdc(*(TMcHitMdc*) tmp);
28191 result7->obj.i = (long) p;
28192 result7->ref = (long) p;
28193 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc));
28194 return(1 || funcname || hash || result7 || libp) ;
28195}
28196
28197// automatic destructor
28198typedef TMcHitMdc G__TTMcHitMdc;
28199static int G__RootEventData_rootcint_560_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28200{
28201 char* gvp = (char*) G__getgvp();
28202 long soff = G__getstructoffset();
28203 int n = G__getaryconstruct();
28204 //
28205 //has_a_delete: 1
28206 //has_own_delete1arg: 0
28207 //has_own_delete2arg: 0
28208 //
28209 if (!soff) {
28210 return(1);
28211 }
28212 if (n) {
28213 if (gvp == (char*)G__PVOID) {
28214 delete[] (TMcHitMdc*) soff;
28215 } else {
28216 G__setgvp((long) G__PVOID);
28217 for (int i = n - 1; i >= 0; --i) {
28218 ((TMcHitMdc*) (soff+(sizeof(TMcHitMdc)*i)))->~G__TTMcHitMdc();
28219 }
28220 G__setgvp((long)gvp);
28221 }
28222 } else {
28223 if (gvp == (char*)G__PVOID) {
28224 delete (TMcHitMdc*) soff;
28225 } else {
28226 G__setgvp((long) G__PVOID);
28227 ((TMcHitMdc*) (soff))->~G__TTMcHitMdc();
28228 G__setgvp((long)gvp);
28229 }
28230 }
28231 G__setnull(result7);
28232 return(1 || funcname || hash || result7 || libp) ;
28233}
28234
28235// automatic assignment operator
28236static int G__RootEventData_rootcint_560_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28237{
28238 TMcHitMdc* dest = (TMcHitMdc*) G__getstructoffset();
28239 *dest = *(TMcHitMdc*) libp->para[0].ref;
28240 const TMcHitMdc& obj = *dest;
28241 result7->ref = (long) (&obj);
28242 result7->obj.i = (long) (&obj);
28243 return(1 || funcname || hash || result7 || libp) ;
28244}
28245
28246
28247/* TMcDigiEmc */
28248static int G__RootEventData_rootcint_561_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28249{
28250 TMcDigiEmc* p = NULL;
28251 char* gvp = (char*) G__getgvp();
28252 int n = G__getaryconstruct();
28253 if (n) {
28254 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
28255 p = new TMcDigiEmc[n];
28256 } else {
28257 p = new((void*) gvp) TMcDigiEmc[n];
28258 }
28259 } else {
28260 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
28261 p = new TMcDigiEmc;
28262 } else {
28263 p = new((void*) gvp) TMcDigiEmc;
28264 }
28265 }
28266 result7->obj.i = (long) p;
28267 result7->ref = (long) p;
28268 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc));
28269 return(1 || funcname || hash || result7 || libp) ;
28270}
28271
28272static int G__RootEventData_rootcint_561_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28273{
28274 ((TMcDigiEmc*) G__getstructoffset())->SetPartId((Int_t) G__int(libp->para[0]));
28275 G__setnull(result7);
28276 return(1 || funcname || hash || result7 || libp) ;
28277}
28278
28279static int G__RootEventData_rootcint_561_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28280{
28281 ((TMcDigiEmc*) G__getstructoffset())->SetThetaNb((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_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28287{
28288 ((TMcDigiEmc*) G__getstructoffset())->SetPhiNb((Int_t) G__int(libp->para[0]));
28289 G__setnull(result7);
28290 return(1 || funcname || hash || result7 || libp) ;
28291}
28292
28293static int G__RootEventData_rootcint_561_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28294{
28295 ((TMcDigiEmc*) G__getstructoffset())->SetEnergy((Double_t) G__double(libp->para[0]));
28296 G__setnull(result7);
28297 return(1 || funcname || hash || result7 || libp) ;
28298}
28299
28300static int G__RootEventData_rootcint_561_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28301{
28302 ((TMcDigiEmc*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
28303 G__setnull(result7);
28304 return(1 || funcname || hash || result7 || libp) ;
28305}
28306
28307static int G__RootEventData_rootcint_561_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28308{
28309 ((TMcDigiEmc*) G__getstructoffset())->SetTrackIndex((Int_t) G__int(libp->para[0]));
28310 G__setnull(result7);
28311 return(1 || funcname || hash || result7 || libp) ;
28312}
28313
28314static int G__RootEventData_rootcint_561_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28315{
28316 G__letint(result7, 105, (long) ((const TMcDigiEmc*) G__getstructoffset())->GetPartId());
28317 return(1 || funcname || hash || result7 || libp) ;
28318}
28319
28320static int G__RootEventData_rootcint_561_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28321{
28322 G__letint(result7, 105, (long) ((const TMcDigiEmc*) G__getstructoffset())->GetThetaNb());
28323 return(1 || funcname || hash || result7 || libp) ;
28324}
28325
28326static int G__RootEventData_rootcint_561_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28327{
28328 G__letint(result7, 105, (long) ((const TMcDigiEmc*) G__getstructoffset())->GetPhiNb());
28329 return(1 || funcname || hash || result7 || libp) ;
28330}
28331
28332static int G__RootEventData_rootcint_561_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28333{
28334 G__letdouble(result7, 100, (double) ((const TMcDigiEmc*) G__getstructoffset())->GetEnergy());
28335 return(1 || funcname || hash || result7 || libp) ;
28336}
28337
28338static int G__RootEventData_rootcint_561_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28339{
28340 G__letdouble(result7, 100, (double) ((const TMcDigiEmc*) G__getstructoffset())->GetTime());
28341 return(1 || funcname || hash || result7 || libp) ;
28342}
28343
28344static int G__RootEventData_rootcint_561_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28345{
28346 G__letint(result7, 105, (long) ((const TMcDigiEmc*) G__getstructoffset())->GetTrackIndex());
28347 return(1 || funcname || hash || result7 || libp) ;
28348}
28349
28350static int G__RootEventData_rootcint_561_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28351{
28352 G__letint(result7, 85, (long) TMcDigiEmc::Class());
28353 return(1 || funcname || hash || result7 || libp) ;
28354}
28355
28356static int G__RootEventData_rootcint_561_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28357{
28358 G__letint(result7, 67, (long) TMcDigiEmc::Class_Name());
28359 return(1 || funcname || hash || result7 || libp) ;
28360}
28361
28362static int G__RootEventData_rootcint_561_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28363{
28364 G__letint(result7, 115, (long) TMcDigiEmc::Class_Version());
28365 return(1 || funcname || hash || result7 || libp) ;
28366}
28367
28368static int G__RootEventData_rootcint_561_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28369{
28370 TMcDigiEmc::Dictionary();
28371 G__setnull(result7);
28372 return(1 || funcname || hash || result7 || libp) ;
28373}
28374
28375static int G__RootEventData_rootcint_561_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28376{
28377 ((TMcDigiEmc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
28378 G__setnull(result7);
28379 return(1 || funcname || hash || result7 || libp) ;
28380}
28381
28382static int G__RootEventData_rootcint_561_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28383{
28384 G__letint(result7, 67, (long) TMcDigiEmc::DeclFileName());
28385 return(1 || funcname || hash || result7 || libp) ;
28386}
28387
28388static int G__RootEventData_rootcint_561_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28389{
28390 G__letint(result7, 105, (long) TMcDigiEmc::ImplFileLine());
28391 return(1 || funcname || hash || result7 || libp) ;
28392}
28393
28394static int G__RootEventData_rootcint_561_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28395{
28396 G__letint(result7, 67, (long) TMcDigiEmc::ImplFileName());
28397 return(1 || funcname || hash || result7 || libp) ;
28398}
28399
28400static int G__RootEventData_rootcint_561_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28401{
28402 G__letint(result7, 105, (long) TMcDigiEmc::DeclFileLine());
28403 return(1 || funcname || hash || result7 || libp) ;
28404}
28405
28406// automatic copy constructor
28407static int G__RootEventData_rootcint_561_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28408
28409{
28410 TMcDigiEmc* p;
28411 void* tmp = (void*) G__int(libp->para[0]);
28412 p = new TMcDigiEmc(*(TMcDigiEmc*) tmp);
28413 result7->obj.i = (long) p;
28414 result7->ref = (long) p;
28415 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc));
28416 return(1 || funcname || hash || result7 || libp) ;
28417}
28418
28419// automatic destructor
28420typedef TMcDigiEmc G__TTMcDigiEmc;
28421static int G__RootEventData_rootcint_561_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28422{
28423 char* gvp = (char*) G__getgvp();
28424 long soff = G__getstructoffset();
28425 int n = G__getaryconstruct();
28426 //
28427 //has_a_delete: 1
28428 //has_own_delete1arg: 0
28429 //has_own_delete2arg: 0
28430 //
28431 if (!soff) {
28432 return(1);
28433 }
28434 if (n) {
28435 if (gvp == (char*)G__PVOID) {
28436 delete[] (TMcDigiEmc*) soff;
28437 } else {
28438 G__setgvp((long) G__PVOID);
28439 for (int i = n - 1; i >= 0; --i) {
28440 ((TMcDigiEmc*) (soff+(sizeof(TMcDigiEmc)*i)))->~G__TTMcDigiEmc();
28441 }
28442 G__setgvp((long)gvp);
28443 }
28444 } else {
28445 if (gvp == (char*)G__PVOID) {
28446 delete (TMcDigiEmc*) soff;
28447 } else {
28448 G__setgvp((long) G__PVOID);
28449 ((TMcDigiEmc*) (soff))->~G__TTMcDigiEmc();
28450 G__setgvp((long)gvp);
28451 }
28452 }
28453 G__setnull(result7);
28454 return(1 || funcname || hash || result7 || libp) ;
28455}
28456
28457// automatic assignment operator
28458static int G__RootEventData_rootcint_561_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28459{
28460 TMcDigiEmc* dest = (TMcDigiEmc*) G__getstructoffset();
28461 *dest = *(TMcDigiEmc*) libp->para[0].ref;
28462 const TMcDigiEmc& obj = *dest;
28463 result7->ref = (long) (&obj);
28464 result7->obj.i = (long) (&obj);
28465 return(1 || funcname || hash || result7 || libp) ;
28466}
28467
28468
28469/* TMcHitEvent */
28470static int G__RootEventData_rootcint_562_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28471{
28472 TMcHitEvent* p = NULL;
28473 char* gvp = (char*) G__getgvp();
28474 int n = G__getaryconstruct();
28475 if (n) {
28476 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
28477 p = new TMcHitEvent[n];
28478 } else {
28479 p = new((void*) gvp) TMcHitEvent[n];
28480 }
28481 } else {
28482 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
28483 p = new TMcHitEvent;
28484 } else {
28485 p = new((void*) gvp) TMcHitEvent;
28486 }
28487 }
28488 result7->obj.i = (long) p;
28489 result7->ref = (long) p;
28490 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent));
28491 return(1 || funcname || hash || result7 || libp) ;
28492}
28493
28494static int G__RootEventData_rootcint_562_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28495{
28496 G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcHitTofCol());
28497 return(1 || funcname || hash || result7 || libp) ;
28498}
28499
28500static int G__RootEventData_rootcint_562_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28501{
28502 ((TMcHitEvent*) G__getstructoffset())->addMcHitTof((TMcHitTof*) G__int(libp->para[0]));
28503 G__setnull(result7);
28504 return(1 || funcname || hash || result7 || libp) ;
28505}
28506
28507static int G__RootEventData_rootcint_562_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28508{
28509 G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcHitTof((Int_t) G__int(libp->para[0])));
28510 return(1 || funcname || hash || result7 || libp) ;
28511}
28512
28513static int G__RootEventData_rootcint_562_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28514{
28515 G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcHitMdcCol());
28516 return(1 || funcname || hash || result7 || libp) ;
28517}
28518
28519static int G__RootEventData_rootcint_562_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28520{
28521 ((TMcHitEvent*) G__getstructoffset())->addMcHitMdc((TMcHitMdc*) G__int(libp->para[0]));
28522 G__setnull(result7);
28523 return(1 || funcname || hash || result7 || libp) ;
28524}
28525
28526static int G__RootEventData_rootcint_562_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28527{
28528 G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcHitMdc((Int_t) G__int(libp->para[0])));
28529 return(1 || funcname || hash || result7 || libp) ;
28530}
28531
28532static int G__RootEventData_rootcint_562_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28533{
28534 G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcDigiEmcCol());
28535 return(1 || funcname || hash || result7 || libp) ;
28536}
28537
28538static int G__RootEventData_rootcint_562_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28539{
28540 ((TMcHitEvent*) G__getstructoffset())->addMcDigiEmc((TMcDigiEmc*) G__int(libp->para[0]));
28541 G__setnull(result7);
28542 return(1 || funcname || hash || result7 || libp) ;
28543}
28544
28545static int G__RootEventData_rootcint_562_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28546{
28547 G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcDigiEmc((Int_t) G__int(libp->para[0])));
28548 return(1 || funcname || hash || result7 || libp) ;
28549}
28550
28551static int G__RootEventData_rootcint_562_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28552{
28553 ((TMcHitEvent*) G__getstructoffset())->setBeamTime((Double_t) G__double(libp->para[0]));
28554 G__setnull(result7);
28555 return(1 || funcname || hash || result7 || libp) ;
28556}
28557
28558static int G__RootEventData_rootcint_562_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28559{
28560 G__letdouble(result7, 100, (double) ((const TMcHitEvent*) G__getstructoffset())->getBeamTime());
28561 return(1 || funcname || hash || result7 || libp) ;
28562}
28563
28564static int G__RootEventData_rootcint_562_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28565{
28566 G__letint(result7, 85, (long) TMcHitEvent::Class());
28567 return(1 || funcname || hash || result7 || libp) ;
28568}
28569
28570static int G__RootEventData_rootcint_562_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28571{
28572 G__letint(result7, 67, (long) TMcHitEvent::Class_Name());
28573 return(1 || funcname || hash || result7 || libp) ;
28574}
28575
28576static int G__RootEventData_rootcint_562_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28577{
28578 G__letint(result7, 115, (long) TMcHitEvent::Class_Version());
28579 return(1 || funcname || hash || result7 || libp) ;
28580}
28581
28582static int G__RootEventData_rootcint_562_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28583{
28584 TMcHitEvent::Dictionary();
28585 G__setnull(result7);
28586 return(1 || funcname || hash || result7 || libp) ;
28587}
28588
28589static int G__RootEventData_rootcint_562_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28590{
28591 ((TMcHitEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
28592 G__setnull(result7);
28593 return(1 || funcname || hash || result7 || libp) ;
28594}
28595
28596static int G__RootEventData_rootcint_562_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28597{
28598 G__letint(result7, 67, (long) TMcHitEvent::DeclFileName());
28599 return(1 || funcname || hash || result7 || libp) ;
28600}
28601
28602static int G__RootEventData_rootcint_562_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28603{
28604 G__letint(result7, 105, (long) TMcHitEvent::ImplFileLine());
28605 return(1 || funcname || hash || result7 || libp) ;
28606}
28607
28608static int G__RootEventData_rootcint_562_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28609{
28610 G__letint(result7, 67, (long) TMcHitEvent::ImplFileName());
28611 return(1 || funcname || hash || result7 || libp) ;
28612}
28613
28614static int G__RootEventData_rootcint_562_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28615{
28616 G__letint(result7, 105, (long) TMcHitEvent::DeclFileLine());
28617 return(1 || funcname || hash || result7 || libp) ;
28618}
28619
28620// automatic copy constructor
28621static int G__RootEventData_rootcint_562_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28622
28623{
28624 TMcHitEvent* p;
28625 void* tmp = (void*) G__int(libp->para[0]);
28626 p = new TMcHitEvent(*(TMcHitEvent*) tmp);
28627 result7->obj.i = (long) p;
28628 result7->ref = (long) p;
28629 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent));
28630 return(1 || funcname || hash || result7 || libp) ;
28631}
28632
28633// automatic destructor
28634typedef TMcHitEvent G__TTMcHitEvent;
28635static int G__RootEventData_rootcint_562_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28636{
28637 char* gvp = (char*) G__getgvp();
28638 long soff = G__getstructoffset();
28639 int n = G__getaryconstruct();
28640 //
28641 //has_a_delete: 1
28642 //has_own_delete1arg: 0
28643 //has_own_delete2arg: 0
28644 //
28645 if (!soff) {
28646 return(1);
28647 }
28648 if (n) {
28649 if (gvp == (char*)G__PVOID) {
28650 delete[] (TMcHitEvent*) soff;
28651 } else {
28652 G__setgvp((long) G__PVOID);
28653 for (int i = n - 1; i >= 0; --i) {
28654 ((TMcHitEvent*) (soff+(sizeof(TMcHitEvent)*i)))->~G__TTMcHitEvent();
28655 }
28656 G__setgvp((long)gvp);
28657 }
28658 } else {
28659 if (gvp == (char*)G__PVOID) {
28660 delete (TMcHitEvent*) soff;
28661 } else {
28662 G__setgvp((long) G__PVOID);
28663 ((TMcHitEvent*) (soff))->~G__TTMcHitEvent();
28664 G__setgvp((long)gvp);
28665 }
28666 }
28667 G__setnull(result7);
28668 return(1 || funcname || hash || result7 || libp) ;
28669}
28670
28671// automatic assignment operator
28672static int G__RootEventData_rootcint_562_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28673{
28674 TMcHitEvent* dest = (TMcHitEvent*) G__getstructoffset();
28675 *dest = *(TMcHitEvent*) libp->para[0].ref;
28676 const TMcHitEvent& obj = *dest;
28677 result7->ref = (long) (&obj);
28678 result7->obj.i = (long) (&obj);
28679 return(1 || funcname || hash || result7 || libp) ;
28680}
28681
28682
28683/* TBossFullEvent */
28684static int G__RootEventData_rootcint_563_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28685{
28686 TBossFullEvent* p = NULL;
28687 char* gvp = (char*) G__getgvp();
28688 int n = G__getaryconstruct();
28689 if (n) {
28690 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
28691 p = new TBossFullEvent[n];
28692 } else {
28693 p = new((void*) gvp) TBossFullEvent[n];
28694 }
28695 } else {
28696 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
28697 p = new TBossFullEvent;
28698 } else {
28699 p = new((void*) gvp) TBossFullEvent;
28700 }
28701 }
28702 result7->obj.i = (long) p;
28703 result7->ref = (long) p;
28704 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent));
28705 return(1 || funcname || hash || result7 || libp) ;
28706}
28707
28708static int G__RootEventData_rootcint_563_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28709{
28710 ((TBossFullEvent*) G__getstructoffset())->copy((TBossFullEvent*) 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_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28716{
28717 ((TBossFullEvent*) G__getstructoffset())->reset();
28718 G__setnull(result7);
28719 return(1 || funcname || hash || result7 || libp) ;
28720}
28721
28722static int G__RootEventData_rootcint_563_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28723{
28724 ((TBossFullEvent*) G__getstructoffset())->setEvtHeader((TEvtHeader*) 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_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28730{
28731 ((TBossFullEvent*) G__getstructoffset())->setDigiEvent((TDigiEvent*) 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_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28737{
28738 ((TBossFullEvent*) G__getstructoffset())->setDstEvent((TDstEvent*) 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_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28744{
28745 ((TBossFullEvent*) G__getstructoffset())->setMcEvent((TMcEvent*) 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_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28751{
28752 ((TBossFullEvent*) G__getstructoffset())->setTrigEvent((TTrigEvent*) G__int(libp->para[0]));
28753 G__setnull(result7);
28754 return(1 || funcname || hash || result7 || libp) ;
28755}
28756
28757static int G__RootEventData_rootcint_563_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28758{
28759 ((TBossFullEvent*) G__getstructoffset())->setHltEvent((THltEvent*) G__int(libp->para[0]));
28760 G__setnull(result7);
28761 return(1 || funcname || hash || result7 || libp) ;
28762}
28763
28764static int G__RootEventData_rootcint_563_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28765{
28766 ((TBossFullEvent*) G__getstructoffset())->setRecTrackEvent((TRecTrackEvent*) G__int(libp->para[0]));
28767 G__setnull(result7);
28768 return(1 || funcname || hash || result7 || libp) ;
28769}
28770
28771static int G__RootEventData_rootcint_563_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28772{
28773 ((TBossFullEvent*) G__getstructoffset())->setEvtRecObject((TEvtRecObject*) G__int(libp->para[0]));
28774 G__setnull(result7);
28775 return(1 || funcname || hash || result7 || libp) ;
28776}
28777
28778static int G__RootEventData_rootcint_563_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28779{
28780 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getEvtHeader());
28781 return(1 || funcname || hash || result7 || libp) ;
28782}
28783
28784static int G__RootEventData_rootcint_563_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28785{
28786 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getDigiEvent());
28787 return(1 || funcname || hash || result7 || libp) ;
28788}
28789
28790static int G__RootEventData_rootcint_563_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28791{
28792 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getDstEvent());
28793 return(1 || funcname || hash || result7 || libp) ;
28794}
28795
28796static int G__RootEventData_rootcint_563_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28797{
28798 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getMcEvent());
28799 return(1 || funcname || hash || result7 || libp) ;
28800}
28801
28802static int G__RootEventData_rootcint_563_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28803{
28804 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getTrigEvent());
28805 return(1 || funcname || hash || result7 || libp) ;
28806}
28807
28808static int G__RootEventData_rootcint_563_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28809{
28810 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getHltEvent());
28811 return(1 || funcname || hash || result7 || libp) ;
28812}
28813
28814static int G__RootEventData_rootcint_563_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28815{
28816 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getRecTrackEvent());
28817 return(1 || funcname || hash || result7 || libp) ;
28818}
28819
28820static int G__RootEventData_rootcint_563_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28821{
28822 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getEvtRecObject());
28823 return(1 || funcname || hash || result7 || libp) ;
28824}
28825
28826static int G__RootEventData_rootcint_563_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28827{
28828 G__letint(result7, 85, (long) TBossFullEvent::Class());
28829 return(1 || funcname || hash || result7 || libp) ;
28830}
28831
28832static int G__RootEventData_rootcint_563_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28833{
28834 G__letint(result7, 67, (long) TBossFullEvent::Class_Name());
28835 return(1 || funcname || hash || result7 || libp) ;
28836}
28837
28838static int G__RootEventData_rootcint_563_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28839{
28840 G__letint(result7, 115, (long) TBossFullEvent::Class_Version());
28841 return(1 || funcname || hash || result7 || libp) ;
28842}
28843
28844static int G__RootEventData_rootcint_563_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28845{
28846 TBossFullEvent::Dictionary();
28847 G__setnull(result7);
28848 return(1 || funcname || hash || result7 || libp) ;
28849}
28850
28851static int G__RootEventData_rootcint_563_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28852{
28853 ((TBossFullEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
28854 G__setnull(result7);
28855 return(1 || funcname || hash || result7 || libp) ;
28856}
28857
28858static int G__RootEventData_rootcint_563_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28859{
28860 G__letint(result7, 67, (long) TBossFullEvent::DeclFileName());
28861 return(1 || funcname || hash || result7 || libp) ;
28862}
28863
28864static int G__RootEventData_rootcint_563_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28865{
28866 G__letint(result7, 105, (long) TBossFullEvent::ImplFileLine());
28867 return(1 || funcname || hash || result7 || libp) ;
28868}
28869
28870static int G__RootEventData_rootcint_563_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28871{
28872 G__letint(result7, 67, (long) TBossFullEvent::ImplFileName());
28873 return(1 || funcname || hash || result7 || libp) ;
28874}
28875
28876static int G__RootEventData_rootcint_563_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28877{
28878 G__letint(result7, 105, (long) TBossFullEvent::DeclFileLine());
28879 return(1 || funcname || hash || result7 || libp) ;
28880}
28881
28882// automatic copy constructor
28883static int G__RootEventData_rootcint_563_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28884
28885{
28886 TBossFullEvent* p;
28887 void* tmp = (void*) G__int(libp->para[0]);
28888 p = new TBossFullEvent(*(TBossFullEvent*) tmp);
28889 result7->obj.i = (long) p;
28890 result7->ref = (long) p;
28891 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent));
28892 return(1 || funcname || hash || result7 || libp) ;
28893}
28894
28895// automatic destructor
28896typedef TBossFullEvent G__TTBossFullEvent;
28897static int G__RootEventData_rootcint_563_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28898{
28899 char* gvp = (char*) G__getgvp();
28900 long soff = G__getstructoffset();
28901 int n = G__getaryconstruct();
28902 //
28903 //has_a_delete: 1
28904 //has_own_delete1arg: 0
28905 //has_own_delete2arg: 0
28906 //
28907 if (!soff) {
28908 return(1);
28909 }
28910 if (n) {
28911 if (gvp == (char*)G__PVOID) {
28912 delete[] (TBossFullEvent*) soff;
28913 } else {
28914 G__setgvp((long) G__PVOID);
28915 for (int i = n - 1; i >= 0; --i) {
28916 ((TBossFullEvent*) (soff+(sizeof(TBossFullEvent)*i)))->~G__TTBossFullEvent();
28917 }
28918 G__setgvp((long)gvp);
28919 }
28920 } else {
28921 if (gvp == (char*)G__PVOID) {
28922 delete (TBossFullEvent*) soff;
28923 } else {
28924 G__setgvp((long) G__PVOID);
28925 ((TBossFullEvent*) (soff))->~G__TTBossFullEvent();
28926 G__setgvp((long)gvp);
28927 }
28928 }
28929 G__setnull(result7);
28930 return(1 || funcname || hash || result7 || libp) ;
28931}
28932
28933// automatic assignment operator
28934static int G__RootEventData_rootcint_563_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28935{
28936 TBossFullEvent* dest = (TBossFullEvent*) G__getstructoffset();
28937 *dest = *(TBossFullEvent*) libp->para[0].ref;
28938 const TBossFullEvent& obj = *dest;
28939 result7->ref = (long) (&obj);
28940 result7->obj.i = (long) (&obj);
28941 return(1 || funcname || hash || result7 || libp) ;
28942}
28943
28944
28945/* Setting up global function */
28946
28947/*********************************************************
28948* Member function Stub
28949*********************************************************/
28950
28951/* TJobInfo */
28952
28953/* TRawData */
28954
28955/* TMdcDigi */
28956
28957/* TEmcDigi */
28958
28959/* TTofDigi */
28960
28961/* TMucDigi */
28962
28963/* TLumiDigi */
28964
28965/* TDigiEvent */
28966
28967/* TRecMdcTrack */
28968
28969/* TRecMdcKalTrack */
28970
28971/* TRecMdcHit */
28972
28973/* TTofTrack */
28974
28975/* TRecTofTrack */
28976
28977/* TRecEmcHit */
28978
28979/* TRecEmcCluster */
28980
28981/* TRecEmcShower */
28982
28983/* TRecMucTrack */
28984
28985/* TRecMdcDedx */
28986
28987/* TRecMdcDedxHit */
28988
28989/* TRecExtTrack */
28990
28991/* TRecEvTime */
28992
28993/* TRecMdcKalHelixSeg */
28994
28995/* TRecZddChannel */
28996
28997/* TRecTrackEvent */
28998
28999/* TMdcTrack */
29000
29001/* TEmcTrack */
29002
29003/* TMucTrack */
29004
29005/* TMdcDedx */
29006
29007/* TExtTrack */
29008
29009/* TMdcKalTrack */
29010
29011/* TDstEvent */
29012
29013/* TMdcMc */
29014
29015/* TEmcMc */
29016
29017/* TTofMc */
29018
29019/* TMucMc */
29020
29021/* TMcParticle */
29022
29023/* TMcEvent */
29024
29025/* TEvtHeader */
29026
29027/* TEvtNavigator */
29028
29029/* TTrigData */
29030
29031/* TTrigEvent */
29032
29033/* THltRaw */
29034
29035/* THltInf */
29036
29037/* TDstHltInf */
29038
29039/* THltEvent */
29040
29041/* TDisTrack */
29042
29043/* TEvtRecEvent */
29044
29045/* TEvtRecTrack */
29046
29047/* TEvtRecPrimaryVertex */
29048
29049/* TEvtRecVeeVertex */
29050
29051/* TEvtRecPi0 */
29052
29053/* TEvtRecEtaToGG */
29054
29055/* TEvtRecDTag */
29056
29057/* TEvtRecObject */
29058
29059/* TMcHitTof */
29060
29061/* TMcHitMdc */
29062
29063/* TMcDigiEmc */
29064
29065/* TMcHitEvent */
29066
29067/* TBossFullEvent */
29068
29069/*********************************************************
29070* Global function Stub
29071*********************************************************/
29072
29073/*********************************************************
29074* Get size of pointer to member function
29075*********************************************************/
29076class G__Sizep2memfuncRootEventData_rootcint {
29077 public:
29078 G__Sizep2memfuncRootEventData_rootcint(): p(&G__Sizep2memfuncRootEventData_rootcint::sizep2memfunc) {}
29079 size_t sizep2memfunc() { return(sizeof(p)); }
29080 private:
29081 size_t (G__Sizep2memfuncRootEventData_rootcint::*p)();
29082};
29083
29084size_t G__get_sizep2memfuncRootEventData_rootcint()
29085{
29086 G__Sizep2memfuncRootEventData_rootcint a;
29087 G__setsizep2memfunc((int)a.sizep2memfunc());
29088 return((size_t)a.sizep2memfunc());
29089}
29090
29091
29092/*********************************************************
29093* virtual base class offset calculation interface
29094*********************************************************/
29095
29096 /* Setting up class inheritance */
29097
29098/*********************************************************
29099* Inheritance information setup/
29100*********************************************************/
29101extern "C" void G__cpp_setup_inheritanceRootEventData_rootcint() {
29102
29103 /* Setting up class inheritance */
29104 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo))) {
29105 TJobInfo *G__Lderived;
29106 G__Lderived=(TJobInfo*)0x1000;
29107 {
29108 TObject *G__Lpbase=(TObject*)G__Lderived;
29109 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);
29110 }
29111 }
29112 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData))) {
29113 TRawData *G__Lderived;
29114 G__Lderived=(TRawData*)0x1000;
29115 {
29116 TObject *G__Lpbase=(TObject*)G__Lderived;
29117 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);
29118 }
29119 }
29120 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi))) {
29121 TMdcDigi *G__Lderived;
29122 G__Lderived=(TMdcDigi*)0x1000;
29123 {
29124 TRawData *G__Lpbase=(TRawData*)G__Lderived;
29125 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);
29126 }
29127 {
29128 TObject *G__Lpbase=(TObject*)G__Lderived;
29129 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);
29130 }
29131 }
29132 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi))) {
29133 TEmcDigi *G__Lderived;
29134 G__Lderived=(TEmcDigi*)0x1000;
29135 {
29136 TRawData *G__Lpbase=(TRawData*)G__Lderived;
29137 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);
29138 }
29139 {
29140 TObject *G__Lpbase=(TObject*)G__Lderived;
29141 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);
29142 }
29143 }
29144 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi))) {
29145 TTofDigi *G__Lderived;
29146 G__Lderived=(TTofDigi*)0x1000;
29147 {
29148 TRawData *G__Lpbase=(TRawData*)G__Lderived;
29149 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);
29150 }
29151 {
29152 TObject *G__Lpbase=(TObject*)G__Lderived;
29153 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);
29154 }
29155 }
29156 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi))) {
29157 TMucDigi *G__Lderived;
29158 G__Lderived=(TMucDigi*)0x1000;
29159 {
29160 TRawData *G__Lpbase=(TRawData*)G__Lderived;
29161 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);
29162 }
29163 {
29164 TObject *G__Lpbase=(TObject*)G__Lderived;
29165 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);
29166 }
29167 }
29168 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi))) {
29169 TLumiDigi *G__Lderived;
29170 G__Lderived=(TLumiDigi*)0x1000;
29171 {
29172 TRawData *G__Lpbase=(TRawData*)G__Lderived;
29173 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);
29174 }
29175 {
29176 TObject *G__Lpbase=(TObject*)G__Lderived;
29177 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);
29178 }
29179 }
29180 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent))) {
29181 TDigiEvent *G__Lderived;
29182 G__Lderived=(TDigiEvent*)0x1000;
29183 {
29184 TObject *G__Lpbase=(TObject*)G__Lderived;
29185 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);
29186 }
29187 }
29188 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack))) {
29189 TRecMdcTrack *G__Lderived;
29190 G__Lderived=(TRecMdcTrack*)0x1000;
29191 {
29192 TObject *G__Lpbase=(TObject*)G__Lderived;
29193 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);
29194 }
29195 }
29196 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack))) {
29197 TRecMdcKalTrack *G__Lderived;
29198 G__Lderived=(TRecMdcKalTrack*)0x1000;
29199 {
29200 TObject *G__Lpbase=(TObject*)G__Lderived;
29201 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);
29202 }
29203 }
29204 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit))) {
29205 TRecMdcHit *G__Lderived;
29206 G__Lderived=(TRecMdcHit*)0x1000;
29207 {
29208 TObject *G__Lpbase=(TObject*)G__Lderived;
29209 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);
29210 }
29211 }
29212 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack))) {
29213 TTofTrack *G__Lderived;
29214 G__Lderived=(TTofTrack*)0x1000;
29215 {
29216 TObject *G__Lpbase=(TObject*)G__Lderived;
29217 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);
29218 }
29219 }
29220 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack))) {
29221 TRecTofTrack *G__Lderived;
29222 G__Lderived=(TRecTofTrack*)0x1000;
29223 {
29224 TObject *G__Lpbase=(TObject*)G__Lderived;
29225 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);
29226 }
29227 }
29228 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit))) {
29229 TRecEmcHit *G__Lderived;
29230 G__Lderived=(TRecEmcHit*)0x1000;
29231 {
29232 TObject *G__Lpbase=(TObject*)G__Lderived;
29233 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);
29234 }
29235 }
29236 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster))) {
29237 TRecEmcCluster *G__Lderived;
29238 G__Lderived=(TRecEmcCluster*)0x1000;
29239 {
29240 TObject *G__Lpbase=(TObject*)G__Lderived;
29241 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);
29242 }
29243 }
29244 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower))) {
29245 TRecEmcShower *G__Lderived;
29246 G__Lderived=(TRecEmcShower*)0x1000;
29247 {
29248 TObject *G__Lpbase=(TObject*)G__Lderived;
29249 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);
29250 }
29251 }
29252 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack))) {
29253 TRecMucTrack *G__Lderived;
29254 G__Lderived=(TRecMucTrack*)0x1000;
29255 {
29256 TObject *G__Lpbase=(TObject*)G__Lderived;
29257 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);
29258 }
29259 }
29260 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx))) {
29261 TRecMdcDedx *G__Lderived;
29262 G__Lderived=(TRecMdcDedx*)0x1000;
29263 {
29264 TObject *G__Lpbase=(TObject*)G__Lderived;
29265 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);
29266 }
29267 }
29268 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit))) {
29269 TRecMdcDedxHit *G__Lderived;
29270 G__Lderived=(TRecMdcDedxHit*)0x1000;
29271 {
29272 TObject *G__Lpbase=(TObject*)G__Lderived;
29273 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);
29274 }
29275 }
29276 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack))) {
29277 TRecExtTrack *G__Lderived;
29278 G__Lderived=(TRecExtTrack*)0x1000;
29279 {
29280 TObject *G__Lpbase=(TObject*)G__Lderived;
29281 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);
29282 }
29283 }
29284 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime))) {
29285 TRecEvTime *G__Lderived;
29286 G__Lderived=(TRecEvTime*)0x1000;
29287 {
29288 TObject *G__Lpbase=(TObject*)G__Lderived;
29289 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);
29290 }
29291 }
29292 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg))) {
29293 TRecMdcKalHelixSeg *G__Lderived;
29294 G__Lderived=(TRecMdcKalHelixSeg*)0x1000;
29295 {
29296 TObject *G__Lpbase=(TObject*)G__Lderived;
29297 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);
29298 }
29299 }
29300 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel))) {
29301 TRecZddChannel *G__Lderived;
29302 G__Lderived=(TRecZddChannel*)0x1000;
29303 {
29304 TObject *G__Lpbase=(TObject*)G__Lderived;
29305 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);
29306 }
29307 }
29308 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent))) {
29309 TRecTrackEvent *G__Lderived;
29310 G__Lderived=(TRecTrackEvent*)0x1000;
29311 {
29312 TObject *G__Lpbase=(TObject*)G__Lderived;
29313 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);
29314 }
29315 }
29316 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack))) {
29317 TMdcTrack *G__Lderived;
29318 G__Lderived=(TMdcTrack*)0x1000;
29319 {
29320 TObject *G__Lpbase=(TObject*)G__Lderived;
29321 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);
29322 }
29323 }
29324 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack))) {
29325 TEmcTrack *G__Lderived;
29326 G__Lderived=(TEmcTrack*)0x1000;
29327 {
29328 TObject *G__Lpbase=(TObject*)G__Lderived;
29329 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);
29330 }
29331 }
29332 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack))) {
29333 TMucTrack *G__Lderived;
29334 G__Lderived=(TMucTrack*)0x1000;
29335 {
29336 TObject *G__Lpbase=(TObject*)G__Lderived;
29337 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);
29338 }
29339 }
29340 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx))) {
29341 TMdcDedx *G__Lderived;
29342 G__Lderived=(TMdcDedx*)0x1000;
29343 {
29344 TObject *G__Lpbase=(TObject*)G__Lderived;
29345 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);
29346 }
29347 }
29348 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack))) {
29349 TExtTrack *G__Lderived;
29350 G__Lderived=(TExtTrack*)0x1000;
29351 {
29352 TObject *G__Lpbase=(TObject*)G__Lderived;
29353 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);
29354 }
29355 }
29356 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack))) {
29357 TMdcKalTrack *G__Lderived;
29358 G__Lderived=(TMdcKalTrack*)0x1000;
29359 {
29360 TObject *G__Lpbase=(TObject*)G__Lderived;
29361 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);
29362 }
29363 }
29364 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent))) {
29365 TDstEvent *G__Lderived;
29366 G__Lderived=(TDstEvent*)0x1000;
29367 {
29368 TObject *G__Lpbase=(TObject*)G__Lderived;
29369 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);
29370 }
29371 }
29372 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc))) {
29373 TMdcMc *G__Lderived;
29374 G__Lderived=(TMdcMc*)0x1000;
29375 {
29376 TObject *G__Lpbase=(TObject*)G__Lderived;
29377 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);
29378 }
29379 }
29380 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc))) {
29381 TEmcMc *G__Lderived;
29382 G__Lderived=(TEmcMc*)0x1000;
29383 {
29384 TObject *G__Lpbase=(TObject*)G__Lderived;
29385 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);
29386 }
29387 }
29388 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc))) {
29389 TTofMc *G__Lderived;
29390 G__Lderived=(TTofMc*)0x1000;
29391 {
29392 TObject *G__Lpbase=(TObject*)G__Lderived;
29393 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);
29394 }
29395 }
29396 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc))) {
29397 TMucMc *G__Lderived;
29398 G__Lderived=(TMucMc*)0x1000;
29399 {
29400 TObject *G__Lpbase=(TObject*)G__Lderived;
29401 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);
29402 }
29403 }
29404 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle))) {
29405 TMcParticle *G__Lderived;
29406 G__Lderived=(TMcParticle*)0x1000;
29407 {
29408 TObject *G__Lpbase=(TObject*)G__Lderived;
29409 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);
29410 }
29411 }
29412 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent))) {
29413 TMcEvent *G__Lderived;
29414 G__Lderived=(TMcEvent*)0x1000;
29415 {
29416 TObject *G__Lpbase=(TObject*)G__Lderived;
29417 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);
29418 }
29419 }
29420 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader))) {
29421 TEvtHeader *G__Lderived;
29422 G__Lderived=(TEvtHeader*)0x1000;
29423 {
29424 TObject *G__Lpbase=(TObject*)G__Lderived;
29425 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);
29426 }
29427 }
29428 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator))) {
29429 TEvtNavigator *G__Lderived;
29430 G__Lderived=(TEvtNavigator*)0x1000;
29431 {
29432 TObject *G__Lpbase=(TObject*)G__Lderived;
29433 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);
29434 }
29435 }
29436 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData))) {
29437 TTrigData *G__Lderived;
29438 G__Lderived=(TTrigData*)0x1000;
29439 {
29440 TObject *G__Lpbase=(TObject*)G__Lderived;
29441 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);
29442 }
29443 }
29444 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent))) {
29445 TTrigEvent *G__Lderived;
29446 G__Lderived=(TTrigEvent*)0x1000;
29447 {
29448 TObject *G__Lpbase=(TObject*)G__Lderived;
29449 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);
29450 }
29451 }
29452 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw))) {
29453 THltRaw *G__Lderived;
29454 G__Lderived=(THltRaw*)0x1000;
29455 {
29456 TRawData *G__Lpbase=(TRawData*)G__Lderived;
29457 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);
29458 }
29459 {
29460 TObject *G__Lpbase=(TObject*)G__Lderived;
29461 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);
29462 }
29463 }
29464 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf))) {
29465 THltInf *G__Lderived;
29466 G__Lderived=(THltInf*)0x1000;
29467 {
29468 TObject *G__Lpbase=(TObject*)G__Lderived;
29469 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);
29470 }
29471 }
29472 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf))) {
29473 TDstHltInf *G__Lderived;
29474 G__Lderived=(TDstHltInf*)0x1000;
29475 {
29476 TObject *G__Lpbase=(TObject*)G__Lderived;
29477 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);
29478 }
29479 }
29480 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent))) {
29481 THltEvent *G__Lderived;
29482 G__Lderived=(THltEvent*)0x1000;
29483 {
29484 TObject *G__Lpbase=(TObject*)G__Lderived;
29485 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);
29486 }
29487 }
29488 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack))) {
29489 TDisTrack *G__Lderived;
29490 G__Lderived=(TDisTrack*)0x1000;
29491 {
29492 TObject *G__Lpbase=(TObject*)G__Lderived;
29493 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);
29494 }
29495 }
29496 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent))) {
29497 TEvtRecEvent *G__Lderived;
29498 G__Lderived=(TEvtRecEvent*)0x1000;
29499 {
29500 TObject *G__Lpbase=(TObject*)G__Lderived;
29501 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);
29502 }
29503 }
29504 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack))) {
29505 TEvtRecTrack *G__Lderived;
29506 G__Lderived=(TEvtRecTrack*)0x1000;
29507 {
29508 TObject *G__Lpbase=(TObject*)G__Lderived;
29509 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);
29510 }
29511 }
29512 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex))) {
29513 TEvtRecPrimaryVertex *G__Lderived;
29514 G__Lderived=(TEvtRecPrimaryVertex*)0x1000;
29515 {
29516 TObject *G__Lpbase=(TObject*)G__Lderived;
29517 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);
29518 }
29519 }
29520 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex))) {
29521 TEvtRecVeeVertex *G__Lderived;
29522 G__Lderived=(TEvtRecVeeVertex*)0x1000;
29523 {
29524 TObject *G__Lpbase=(TObject*)G__Lderived;
29525 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);
29526 }
29527 }
29528 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0))) {
29529 TEvtRecPi0 *G__Lderived;
29530 G__Lderived=(TEvtRecPi0*)0x1000;
29531 {
29532 TObject *G__Lpbase=(TObject*)G__Lderived;
29533 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);
29534 }
29535 }
29536 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG))) {
29537 TEvtRecEtaToGG *G__Lderived;
29538 G__Lderived=(TEvtRecEtaToGG*)0x1000;
29539 {
29540 TObject *G__Lpbase=(TObject*)G__Lderived;
29541 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);
29542 }
29543 }
29544 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag))) {
29545 TEvtRecDTag *G__Lderived;
29546 G__Lderived=(TEvtRecDTag*)0x1000;
29547 {
29548 TObject *G__Lpbase=(TObject*)G__Lderived;
29549 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);
29550 }
29551 }
29552 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject))) {
29553 TEvtRecObject *G__Lderived;
29554 G__Lderived=(TEvtRecObject*)0x1000;
29555 {
29556 TObject *G__Lpbase=(TObject*)G__Lderived;
29557 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);
29558 }
29559 }
29560 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof))) {
29561 TMcHitTof *G__Lderived;
29562 G__Lderived=(TMcHitTof*)0x1000;
29563 {
29564 TObject *G__Lpbase=(TObject*)G__Lderived;
29565 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);
29566 }
29567 }
29568 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc))) {
29569 TMcHitMdc *G__Lderived;
29570 G__Lderived=(TMcHitMdc*)0x1000;
29571 {
29572 TObject *G__Lpbase=(TObject*)G__Lderived;
29573 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);
29574 }
29575 }
29576 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc))) {
29577 TMcDigiEmc *G__Lderived;
29578 G__Lderived=(TMcDigiEmc*)0x1000;
29579 {
29580 TObject *G__Lpbase=(TObject*)G__Lderived;
29581 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);
29582 }
29583 }
29584 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent))) {
29585 TMcHitEvent *G__Lderived;
29586 G__Lderived=(TMcHitEvent*)0x1000;
29587 {
29588 TObject *G__Lpbase=(TObject*)G__Lderived;
29589 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);
29590 }
29591 }
29592 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent))) {
29593 TBossFullEvent *G__Lderived;
29594 G__Lderived=(TBossFullEvent*)0x1000;
29595 {
29596 TObject *G__Lpbase=(TObject*)G__Lderived;
29597 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);
29598 }
29599 }
29600}
29601
29602/*********************************************************
29603* typedef information setup/
29604*********************************************************/
29605extern "C" void G__cpp_setup_typetableRootEventData_rootcint() {
29606
29607 /* Setting up typedef entry */
29608 G__search_typename2("Int_t",105,-1,0,-1);
29609 G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
29610 G__search_typename2("UInt_t",104,-1,0,-1);
29611 G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
29612 G__search_typename2("ULong_t",107,-1,0,-1);
29613 G__setnewtype(-1,"Unsigned long integer 8 bytes (unsigned long)",0);
29614 G__search_typename2("Double_t",100,-1,0,-1);
29615 G__setnewtype(-1,"Double 8 bytes",0);
29616 G__search_typename2("Bool_t",103,-1,0,-1);
29617 G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
29618 G__search_typename2("Version_t",115,-1,0,-1);
29619 G__setnewtype(-1,"Class version identifier (short)",0);
29620 G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
29621 G__setnewtype(-1,NULL,0);
29622 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));
29623 G__setnewtype(-1,NULL,0);
29624 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));
29625 G__setnewtype(-1,NULL,0);
29626 G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
29627 G__setnewtype(-1,NULL,0);
29628 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));
29629 G__setnewtype(-1,NULL,0);
29630 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));
29631 G__setnewtype(-1,NULL,0);
29632 G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
29633 G__setnewtype(-1,NULL,0);
29634 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));
29635 G__setnewtype(-1,NULL,0);
29636 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));
29637 G__setnewtype(-1,NULL,0);
29638 G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
29639 G__setnewtype(-1,NULL,0);
29640 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));
29641 G__setnewtype(-1,NULL,0);
29642 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));
29643 G__setnewtype(-1,NULL,0);
29644 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);
29645 G__setnewtype(-1,NULL,0);
29646 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);
29647 G__setnewtype(-1,NULL,0);
29648 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
29649 G__setnewtype(-1,NULL,0);
29650 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
29651 G__setnewtype(-1,NULL,0);
29652 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
29653 G__setnewtype(-1,NULL,0);
29654 G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
29655 G__setnewtype(-1,NULL,0);
29656 G__search_typename2("map<Int_t,Double_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
29657 G__setnewtype(-1,NULL,0);
29658 G__search_typename2("map<int,double>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
29659 G__setnewtype(-1,NULL,0);
29660 G__search_typename2("map<int,double,less<int> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
29661 G__setnewtype(-1,NULL,0);
29662 G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
29663 G__setnewtype(-1,NULL,0);
29664 G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
29665 G__setnewtype(-1,NULL,0);
29666 G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
29667 G__setnewtype(-1,NULL,0);
29668 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));
29669 G__setnewtype(-1,NULL,0);
29670 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));
29671 G__setnewtype(-1,NULL,0);
29672 G__search_typename2("vector<vector<Double_t> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
29673 G__setnewtype(-1,NULL,0);
29674 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));
29675 G__setnewtype(-1,NULL,0);
29676 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));
29677 G__setnewtype(-1,NULL,0);
29678 G__search_typename2("vector<vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
29679 G__setnewtype(-1,NULL,0);
29680 G__search_typename2("pair<Int_t,Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_pairlEintcOfloatgR),0,-1);
29681 G__setnewtype(-1,NULL,0);
29682 G__search_typename2("vector<std::pair<Int_t,Float_t> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
29683 G__setnewtype(-1,NULL,0);
29684 G__search_typename2("vector<pair<Int_t,Float_t> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
29685 G__setnewtype(-1,NULL,0);
29686 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));
29687 G__setnewtype(-1,NULL,0);
29688 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));
29689 G__setnewtype(-1,NULL,0);
29690 G__search_typename2("vector<pair<int,float> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
29691 G__setnewtype(-1,NULL,0);
29692 G__search_typename2("Fragments",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
29693 G__setnewtype(-1,NULL,0);
29694 G__search_typename2("multimap<int,int>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),0,-1);
29695 G__setnewtype(-1,NULL,0);
29696 G__search_typename2("multimap<int,int,less<int> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),0,-1);
29697 G__setnewtype(-1,NULL,0);
29698 G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR),0,-1);
29699 G__setnewtype(-1,NULL,0);
29700 G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR),0,-1);
29701 G__setnewtype(-1,NULL,0);
29702 G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVectorTlEfloatgR),0,-1);
29703 G__setnewtype(-1,NULL,0);
29704 G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVectorTlEdoublegR),0,-1);
29705 G__setnewtype(-1,NULL,0);
29706 G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTlEfloatgR),0,-1);
29707 G__setnewtype(-1,NULL,0);
29708 G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR),0,-1);
29709 G__setnewtype(-1,NULL,0);
29710 G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR),0,-1);
29711 G__setnewtype(-1,NULL,0);
29712 G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR),0,-1);
29713 G__setnewtype(-1,NULL,0);
29714 G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR),0,-1);
29715 G__setnewtype(-1,NULL,0);
29716 G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR),0,-1);
29717 G__setnewtype(-1,NULL,0);
29718 G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
29719 G__setnewtype(-1,NULL,0);
29720 G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
29721 G__setnewtype(-1,NULL,0);
29722 G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR),0,-1);
29723 G__setnewtype(-1,NULL,0);
29724 G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR),0,-1);
29725 G__setnewtype(-1,NULL,0);
29726 G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR),0,-1);
29727 G__setnewtype(-1,NULL,0);
29728 G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR),0,-1);
29729 G__setnewtype(-1,NULL,0);
29730 G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSublEfloatgR),0,-1);
29731 G__setnewtype(-1,NULL,0);
29732 G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR),0,-1);
29733 G__setnewtype(-1,NULL,0);
29734 G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR),0,-1);
29735 G__setnewtype(-1,NULL,0);
29736 G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TElementActionTlEfloatgR),0,-1);
29737 G__setnewtype(-1,NULL,0);
29738 G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR),0,-1);
29739 G__setnewtype(-1,NULL,0);
29740}
29741
29742/*********************************************************
29743* Data Member information setup/
29744*********************************************************/
29745
29746 /* Setting up class,struct,union tag member variable */
29747
29748 /* TJobInfo */
29749static void G__setup_memvarTJobInfo(void) {
29750 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo));
29751 { TJobInfo *p; p=(TJobInfo*)0x1000; if (p) { }
29752 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_string),-1,-1,4,"m_decayOptions=",0,(char*)NULL);
29753 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_string),-1,-1,4,"m_bossVer=",0,(char*)NULL);
29754 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);
29755 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);
29756 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29757 }
29758 G__tag_memvar_reset();
29759}
29760
29761
29762 /* TRawData */
29763static void G__setup_memvarTRawData(void) {
29764 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData));
29765 { TRawData *p; p=(TRawData*)0x1000; if (p) { }
29766 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_intId=",0,(char*)NULL);
29767 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_timeChannel=",0,(char*)NULL);
29768 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_chargeChannel=",0,(char*)NULL);
29769 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
29770 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29771 }
29772 G__tag_memvar_reset();
29773}
29774
29775
29776 /* TMdcDigi */
29777static void G__setup_memvarTMdcDigi(void) {
29778 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi));
29779 { TMdcDigi *p; p=(TMdcDigi*)0x1000; if (p) { }
29780 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_overflow=",0,(char*)NULL);
29781 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29782 }
29783 G__tag_memvar_reset();
29784}
29785
29786
29787 /* TEmcDigi */
29788static void G__setup_memvarTEmcDigi(void) {
29789 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi));
29790 { TEmcDigi *p; p=(TEmcDigi*)0x1000; if (p) { }
29791 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_measure=",0,(char*)NULL);
29792 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29793 }
29794 G__tag_memvar_reset();
29795}
29796
29797
29798 /* TTofDigi */
29799static void G__setup_memvarTTofDigi(void) {
29800 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi));
29801 { TTofDigi *p; p=(TTofDigi*)0x1000; if (p) { }
29802 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_overflow=",0,(char*)NULL);
29803 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29804 }
29805 G__tag_memvar_reset();
29806}
29807
29808
29809 /* TMucDigi */
29810static void G__setup_memvarTMucDigi(void) {
29811 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi));
29812 { TMucDigi *p; p=(TMucDigi*)0x1000; if (p) { }
29813 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29814 }
29815 G__tag_memvar_reset();
29816}
29817
29818
29819 /* TLumiDigi */
29820static void G__setup_memvarTLumiDigi(void) {
29821 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi));
29822 { TLumiDigi *p; p=(TLumiDigi*)0x1000; if (p) { }
29823 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_overflow=",0,(char*)NULL);
29824 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29825 }
29826 G__tag_memvar_reset();
29827}
29828
29829
29830 /* TDigiEvent */
29831static void G__setup_memvarTDigiEvent(void) {
29832 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent));
29833 { TDigiEvent *p; p=(TDigiEvent*)0x1000; if (p) { }
29834 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_fromMc=",0,(char*)NULL);
29835 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcDigiCol=",0,(char*)NULL);
29836 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcDigiCol=",0,"-> ");
29837 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcDigiCol=",0,(char*)NULL);
29838 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_emcDigiCol=",0,"->");
29839 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticTofDigiCol=",0,(char*)NULL);
29840 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tofDigiCol=",0,"->");
29841 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMucDigiCol=",0,(char*)NULL);
29842 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mucDigiCol=",0,"->");
29843 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticLumiDigiCol=",0,(char*)NULL);
29844 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_lumiDigiCol=",0,"->");
29845 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29846 }
29847 G__tag_memvar_reset();
29848}
29849
29850
29851 /* TRecMdcTrack */
29852static void G__setup_memvarTRecMdcTrack(void) {
29853 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack));
29854 { TRecMdcTrack *p; p=(TRecMdcTrack*)0x1000; if (p) { }
29855 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 ");
29856 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_helix[5]=",0,"5 track parameters");
29857 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat=",0,"Track Fit Quality");
29858 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,(char*)NULL);
29859 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndof=",0,(char*)NULL);
29860 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_err[15]=",0,"Error Matrix");
29861 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nhits=",0,"number of total hits contained");
29862 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nster=",0,"number of stereo hits contained");
29863 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nlayer=",0,"number of layer hits contained");
29864 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_vx0=",0,"The coordinate of pivot(cm)");
29865 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_vy0=",0,(char*)NULL);
29866 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_vz0=",0,(char*)NULL);
29867 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");
29868 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29869 }
29870 G__tag_memvar_reset();
29871}
29872
29873
29874 /* TRecMdcKalTrack */
29875static void G__setup_memvarTRecMdcKalTrack(void) {
29876 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack));
29877 { TRecMdcKalTrack *p; p=(TRecMdcKalTrack*)0x1000; if (p) { }
29878 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 ");
29879 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 ");
29880 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");
29881 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; ");
29882 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fiTerm[5]=",0,"terminal phi ");
29883 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pathSM[5]=",0,(char*)NULL);
29884 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 ");
29885 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");
29886 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat[2][5]=",0,"status flag ");
29887 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 ");
29888 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 ");
29889 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nSegs[5]=",0,"number of segments");
29890 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca[3]=",0,(char*)NULL);
29891 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca_e[3]=",0,(char*)NULL);
29892 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca_mu[3]=",0,(char*)NULL);
29893 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca_k[3]=",0,(char*)NULL);
29894 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca_p[3]=",0,(char*)NULL);
29895 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint[3]=",0,(char*)NULL);
29896 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint_e[3]=",0,(char*)NULL);
29897 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint_mu[3]=",0,(char*)NULL);
29898 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint_k[3]=",0,(char*)NULL);
29899 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint_p[3]=",0,(char*)NULL);
29900 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot[3]=",0,(char*)NULL);
29901 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot_e[3]=",0,(char*)NULL);
29902 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot_mu[3]=",0,(char*)NULL);
29903 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot_k[3]=",0,(char*)NULL);
29904 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot_p[3]=",0,(char*)NULL);
29905 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 ");
29906 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 ");
29907 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 ");
29908 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 ");
29909 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 ");
29910 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 ; ");
29911 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 ");
29912 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 ");
29913 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 ");
29914 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 ");
29915 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 ");
29916 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 ");
29917 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 ");
29918 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 ");
29919 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 ");
29920 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 ; ");
29921 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 ");
29922 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 ");
29923 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 ");
29924 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 ");
29925 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 ");
29926 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 ");
29927 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 ");
29928 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 ");
29929 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 ");
29930 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 ; ");
29931 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 ");
29932 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 ");
29933 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 ");
29934 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 ");
29935 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 ");
29936 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 ");
29937 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29938 }
29939 G__tag_memvar_reset();
29940}
29941
29942
29943 /* TRecMdcHit */
29944static void G__setup_memvarTRecMdcHit(void) {
29945 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit));
29946 { TRecMdcHit *p; p=(TRecMdcHit*)0x1000; if (p) { }
29947 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_isGrouped=",0,(char*)NULL);
29948 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_id=",0,(char*)NULL);
29949 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 ");
29950 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ddl=",0,"drift distance left");
29951 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ddr=",0,"drift distance right");
29952 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_erddl=",0,"error of drift distance left");
29953 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_erddr=",0,"error of drift distance right");
29954 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pChisq=",0,"contribution to chisquare");
29955 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");
29956 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat=",0,"status flag");
29957 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_mdcid=",0,"MDC identifier");
29958 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tdc=",0,"corrected TDC");
29959 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_adc=",0,"corrected ADC");
29960 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_driftT=",0,"drift time");
29961 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");
29962 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_entra=",0,"entrance angle in azimuth");
29963 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhit=",0,"z coordinate of the hit");
29964 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fltLen=",0,"flight length of this hit");
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 /* TTofTrack */
29972static void G__setup_memvarTTofTrack(void) {
29973 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack));
29974 { TTofTrack *p; p=(TTofTrack*)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 /* TRecTofTrack */
30002static void G__setup_memvarTRecTofTrack(void) {
30003 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack));
30004 { TRecTofTrack *p; p=(TRecTofTrack*)0x1000; if (p) { }
30005 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");
30006 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.");
30007 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_tofID=",0,"Tof Counter ID.");
30008 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_status=",0,"Status.");
30009 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_path=",0,"Distance of flight.");
30010 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.");
30011 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ph=",0,"Pulse height.");
30012 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tof=",0,"Time of flight.");
30013 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_beta=",0,"Beta value of the track.");
30014 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.");
30015 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.");
30016 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.");
30017 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_quality=",0,"Data quality of reconstruction.");
30018 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_t0=",0,"t0 from data set calibration.");
30019 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errt0=",0,"t0 sigma from tof calibration.");
30020 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.");
30021 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.");
30022 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errphi=",0,"Error of angle of phi.");
30023 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,"Energy deposit for neutral track");
30024 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. ");
30025 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30026 }
30027 G__tag_memvar_reset();
30028}
30029
30030
30031 /* TRecEmcHit */
30032static void G__setup_memvarTRecEmcHit(void) {
30033 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit));
30034 { TRecEmcHit *p; p=(TRecEmcHit*)0x1000; if (p) { }
30035 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_cellId=",0,(char*)NULL);
30036 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,(char*)NULL);
30037 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,(char*)NULL);
30038 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30039 }
30040 G__tag_memvar_reset();
30041}
30042
30043
30044 /* TRecEmcCluster */
30045static void G__setup_memvarTRecEmcCluster(void) {
30046 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster));
30047 { TRecEmcCluster *p; p=(TRecEmcCluster*)0x1000; if (p) { }
30048 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_clusterId=",0,(char*)NULL);
30049 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);
30050 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);
30051 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);
30052 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30053 }
30054 G__tag_memvar_reset();
30055}
30056
30057
30058 /* TRecEmcShower */
30059static void G__setup_memvarTRecEmcShower(void) {
30060 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower));
30061 { TRecEmcShower *p; p=(TRecEmcShower*)0x1000; if (p) { }
30062 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 ");
30063 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numHits=",0,"Total number of hits");
30064 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Status");
30065 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_cellId=",0,"Cell ID");
30066 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_module=",0,"Module");
30067 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_x=",0,"Shower coordinates and errors");
30068 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_y=",0,(char*)NULL);
30069 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_z=",0,(char*)NULL);
30070 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_theta=",0,"Shower Counter angles and errors");
30071 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dTheta=",0,(char*)NULL);
30072 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_phi=",0,(char*)NULL);
30073 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dPhi=",0,(char*)NULL);
30074 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,"Total energy observed in Emc");
30075 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dE=",0,(char*)NULL);
30076 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eSeed=",0,"// Energy of seed, only one");
30077 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");
30078 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");
30079 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");
30080 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");
30081 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,"Time");
30082 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_secondMoment=",0,"add 2006-07-03");
30083 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_latMoment=",0,"Lateral moment");
30084 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_a20Moment=",0,"Zernike moment");
30085 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_a42Moment=",0,(char*)NULL);
30086 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");
30087 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");
30088 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");
30089 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");
30090 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_clusterId=",0,"Cluster ID");
30091 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30092 }
30093 G__tag_memvar_reset();
30094}
30095
30096
30097 /* TRecMucTrack */
30098static void G__setup_memvarTRecMucTrack(void) {
30099 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack));
30100 { TRecMucTrack *p; p=(TRecMucTrack*)0x1000; if (p) { }
30101 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");
30102 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_id=",0,"Muc Identifier");
30103 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Muc Status");
30104 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_type=",0,"Method of judge?");
30105 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");
30106 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");
30107 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 ");
30108 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 ");
30109 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numHits=",0,"Number of hits on track");
30110 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numLayers=",0,"Number of layer with hits");
30111 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");
30112 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depth=",0,"Depth of iron penetrated");
30113 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,"Fit parameters");
30114 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_dof=",0,(char*)NULL);
30115 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_rms=",0,(char*)NULL);
30116 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");
30117 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");
30118 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");
30119 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");
30120 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");
30121 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");
30122 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,"px on muc track vertex");
30123 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,"py on muc track vertex");
30124 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,"pz on muc track vertex");
30125 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");
30126 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");
30127 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");
30128 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 ");
30129 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 ");
30130 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_kalrechi2=",0,(char*)NULL);
30131 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kaldof=",0,(char*)NULL);
30132 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_kaldepth=",0,(char*)NULL);
30133 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kalbrLastLayer=",0,(char*)NULL);
30134 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kalecLastLayer=",0,(char*)NULL);
30135 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30136 }
30137 G__tag_memvar_reset();
30138}
30139
30140
30141 /* TRecMdcDedx */
30142static void G__setup_memvarTRecMdcDedx(void) {
30143 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx));
30144 { TRecMdcDedx *p; p=(TRecMdcDedx*)0x1000; if (p) { }
30145 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");
30146 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");
30147 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");
30148 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");
30149 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");
30150 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcTrackId=",0,(char*)NULL);
30151 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcKalTrackId=",0,(char*)NULL);
30152 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");
30153 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Status");
30154 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trunc_alg=",0,"truncate method");
30155 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiE=",0,"Number of sigama from e");
30156 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiMu=",0,"Number of sigama from muon");
30157 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiPi=",0,"Number of sigama from pion");
30158 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiK=",0,"Number of sigama from k");
30159 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiP=",0,"Number of sigama from p");
30160 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)");
30161 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)");
30162 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");
30163 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");
30164 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errorPH=",0,"resolution of truncated mean ");
30165 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% ");
30166 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");
30167 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");
30168 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");
30169 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");
30170 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30171 }
30172 G__tag_memvar_reset();
30173}
30174
30175
30176 /* TRecMdcDedxHit */
30177static void G__setup_memvarTRecMdcDedxHit(void) {
30178 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit));
30179 { TRecMdcDedxHit *p; p=(TRecMdcDedxHit*)0x1000; if (p) { }
30180 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_isGrouped=",0,(char*)NULL);
30181 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;");
30182 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;");
30183 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;");
30184 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");
30185 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_mdcid=",0,"MDC identifier");
30186 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pathlength=",0,(char*)NULL);
30187 G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"m_dedx=",0,(char*)NULL);
30188 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30189 }
30190 G__tag_memvar_reset();
30191}
30192
30193
30194 /* TRecExtTrack */
30195static void G__setup_memvarTRecExtTrack(void) {
30196 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack));
30197 { TRecExtTrack *p; p=(TRecExtTrack*)0x1000; if (p) { }
30198 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");
30199 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.");
30200 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");
30201 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");
30202 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.");
30203 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.");
30204 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.");
30205 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");
30206 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myTof1VolumeNumber[5]=",0,"Scintillator volume number");
30207 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1[5]=",0,"Time of flight");
30208 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1Path[5]=",0,"Path of flight");
30209 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongZ[5]=",0,"Sigma Z");
30210 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongT[5]=",0,"Sigma along Z x R");
30211 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongX[5]=",0,"Sigma X");
30212 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongY[5]=",0,"Sigma Y");
30213 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)");
30214 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.");
30215 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");
30216 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");
30217 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");
30218 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");
30219 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");
30220 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");
30221 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myTof2VolumeNumber[5]=",0,"Scintillator volume number");
30222 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2[5]=",0,"Time of flight");
30223 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2Path[5]=",0,"Path of flight");
30224 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongZ[5]=",0,"Sigma Z");
30225 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongT[5]=",0,"Sigma along Z x R");
30226 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongX[5]=",0,"Sigma X");
30227 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongY[5]=",0,"Sigma Y");
30228 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)");
30229 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionX[5]=",0,"Position 2.");
30230 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionY[5]=",0,"Position 2");
30231 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionZ[5]=",0,"Position 2");
30232 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumX[5]=",0,"Momentum ");
30233 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumY[5]=",0,"Momentum ");
30234 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumZ[5]=",0,"Momentum ");
30235 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");
30236 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myEmcVolumeNumber[5]=",0,"Scintillator volume number");
30237 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPosSigmaAlongTheta[5]=",0,(char*)NULL);
30238 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPosSigmaAlongPhi[5]=",0,(char*)NULL);
30239 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)");
30240 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPath[5]=",0,(char*)NULL);
30241 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionX[5]=",0,"Position 2.");
30242 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionY[5]=",0,"Position 2");
30243 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionZ[5]=",0,"Position 2");
30244 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumX[5]=",0,"Momentum ");
30245 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumY[5]=",0,"Momentum ");
30246 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumZ[5]=",0,"Momentum ");
30247 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");
30248 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myMucVolumeNumber[5]=",0,"Scintillator volume number");
30249 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongZ[5]=",0,(char*)NULL);
30250 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongT[5]=",0,(char*)NULL);
30251 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongX[5]=",0,(char*)NULL);
30252 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongY[5]=",0,(char*)NULL);
30253 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucErrorMatrix[5][6][6]=",0,(char*)NULL);
30254 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"mySize[5]=",0,"size of the vector ");
30255 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);
30256 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);
30257 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);
30258 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);
30259 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);
30260 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);
30261 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);
30262 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);
30263 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);
30264 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);
30265 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);
30266 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);
30267 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);
30268 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30269 }
30270 G__tag_memvar_reset();
30271}
30272
30273
30274 /* TRecEvTime */
30275static void G__setup_memvarTRecEvTime(void) {
30276 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime));
30277 { TRecEvTime *p; p=(TRecEvTime*)0x1000; if (p) { }
30278 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,(char*)NULL);
30279 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_estime=",0,(char*)NULL);
30280 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_quality=",0,(char*)NULL);
30281 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30282 }
30283 G__tag_memvar_reset();
30284}
30285
30286
30287 /* TRecMdcKalHelixSeg */
30288static void G__setup_memvarTRecMdcKalHelixSeg(void) {
30289 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg));
30290 { TRecMdcKalHelixSeg *p; p=(TRecMdcKalHelixSeg*)0x1000; if (p) { }
30291 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 ");
30292 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");
30293 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_mdcid=",0,"MDC identifier");
30294 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tdc=",0,"corrected TDC");
30295 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_adc=",0,"corrected ADC");
30296 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhit=",0,"z coordinate of the hit");
30297 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tof=",0,"time of flight ");
30298 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");
30299 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_docaexcl=",0,(char*)NULL);
30300 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dd=",0,"drift distance ");
30301 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_entra=",0,"entrance angle in azimuth");
30302 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_driftT=",0,"drift time");
30303 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_helixincl[5]=",0,(char*)NULL);
30304 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_helixexcl[5]=",0,(char*)NULL);
30305 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30306 }
30307 G__tag_memvar_reset();
30308}
30309
30310
30311 /* TRecZddChannel */
30312static void G__setup_memvarTRecZddChannel(void) {
30313 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
30314 { TRecZddChannel *p; p=(TRecZddChannel*)0x1000; if (p) { }
30315 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_chId=",0,(char*)NULL);
30316 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_scanCode=",0,(char*)NULL);
30317 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_baseLine=",0,(char*)NULL);
30318 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_phase=",0,(char*)NULL);
30319 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);
30320 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30321 }
30322 G__tag_memvar_reset();
30323}
30324
30325
30326 /* TRecTrackEvent */
30327static void G__setup_memvarTRecTrackEvent(void) {
30328 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent));
30329 { TRecTrackEvent *p; p=(TRecTrackEvent*)0x1000; if (p) { }
30330 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcTrackCol=",0,(char*)NULL);
30331 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcTrackCol=",0,"-> ");
30332 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcHitCol=",0,(char*)NULL);
30333 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcHitCol=",0,"->");
30334 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcHitCol=",0,(char*)NULL);
30335 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEmcHitCol=",0,"-> ");
30336 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcClusterCol=",0,(char*)NULL);
30337 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEmcClusterCol=",0,"-> ");
30338 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcShowerCol=",0,(char*)NULL);
30339 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEmcShowerCol=",0,"-> ");
30340 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticTofTrackCol=",0,(char*)NULL);
30341 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recTofTrackCol=",0,"->");
30342 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMucTrackCol=",0,(char*)NULL);
30343 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMucTrackCol=",0,"->");
30344 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcDedxCol=",0,(char*)NULL);
30345 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcDedxCol=",0,"-> ");
30346 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcDedxHitCol=",0,(char*)NULL);
30347 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcDedxHitCol=",0,"->");
30348 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticExtTrackCol=",0,(char*)NULL);
30349 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recExtTrackCol=",0,"-> ");
30350 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcKalTrackCol=",0,(char*)NULL);
30351 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcKalTrackCol=",0,"->");
30352 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcKalHelixSegCol=",0,(char*)NULL);
30353 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcKalHelixSegCol=",0,"->");
30354 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvTimeCol=",0,(char*)NULL);
30355 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEvTimeCol=",0,"->");
30356 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecZddChannelCol=",0,(char*)NULL);
30357 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recZddChannelCol=",0,"->");
30358 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30359 }
30360 G__tag_memvar_reset();
30361}
30362
30363
30364 /* TMdcTrack */
30365static void G__setup_memvarTMdcTrack(void) {
30366 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack));
30367 { TMdcTrack *p; p=(TMdcTrack*)0x1000; if (p) { }
30368 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 ");
30369 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_helix[5]=",0,"5 track parameters");
30370 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_err[15]=",0,"Error Matrix");
30371 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat=",0,"Track Fit Quality");
30372 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,(char*)NULL);
30373 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndof=",0,(char*)NULL);
30374 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nster=",0,"number of stereo hits contained");
30375 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nlayer=",0,"number of layer track passed");
30376 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_firstLayer=",0,(char*)NULL);
30377 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_lastLayer=",0,(char*)NULL);
30378 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30379 }
30380 G__tag_memvar_reset();
30381}
30382
30383
30384 /* TEmcTrack */
30385static void G__setup_memvarTEmcTrack(void) {
30386 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack));
30387 { TEmcTrack *p; p=(TEmcTrack*)0x1000; if (p) { }
30388 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 ");
30389 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numHits=",0,"Total number of hits");
30390 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Status");
30391 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_cellId=",0,"Cell ID");
30392 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_module=",0,"Module");
30393 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_x=",0,"Shower coordinates and errors");
30394 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_y=",0,(char*)NULL);
30395 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_z=",0,(char*)NULL);
30396 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dTheta=",0,(char*)NULL);
30397 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dPhi=",0,(char*)NULL);
30398 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,"Total energy observed in Emc");
30399 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dE=",0,(char*)NULL);
30400 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eSeed=",0,"// Energy of seed, only one");
30401 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");
30402 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");
30403 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,"Time measurement");
30404 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_secondMoment=",0,"add 2006-07-03");
30405 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_latMoment=",0,"Lateral moment");
30406 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_a20Moment=",0,"Zernike moment");
30407 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_a42Moment=",0,(char*)NULL);
30408 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");
30409 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30410 }
30411 G__tag_memvar_reset();
30412}
30413
30414
30415 /* TMucTrack */
30416static void G__setup_memvarTMucTrack(void) {
30417 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack));
30418 { TMucTrack *p; p=(TMucTrack*)0x1000; if (p) { }
30419 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");
30420 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_id=",0,"Muc Identifier");
30421 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Muc Status");
30422 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_type=",0,"Method of judge?");
30423 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");
30424 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");
30425 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 ");
30426 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 ");
30427 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numHits=",0,"Number of hits on track");
30428 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numLayers=",0,"Number of layer with hits");
30429 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");
30430 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depth=",0,"Depth of iron penetrated");
30431 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,"Fit parameters");
30432 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_dof=",0,(char*)NULL);
30433 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_rms=",0,(char*)NULL);
30434 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");
30435 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");
30436 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");
30437 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosSigma=",0,(char*)NULL);
30438 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosSigma=",0,(char*)NULL);
30439 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosSigma=",0,(char*)NULL);
30440 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,"px on muc track vertex");
30441 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,"py on muc track vertex");
30442 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,"pz on muc track vertex");
30443 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_distance=",0,(char*)NULL);
30444 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_deltaPhi=",0,(char*)NULL);
30445 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_kalrechi2=",0,(char*)NULL);
30446 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kaldof=",0,(char*)NULL);
30447 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_kaldepth=",0,(char*)NULL);
30448 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kalbrLastLayer=",0,(char*)NULL);
30449 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kalecLastLayer=",0,(char*)NULL);
30450 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30451 }
30452 G__tag_memvar_reset();
30453}
30454
30455
30456 /* TMdcDedx */
30457static void G__setup_memvarTMdcDedx(void) {
30458 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx));
30459 { TMdcDedx *p; p=(TMdcDedx*)0x1000; if (p) { }
30460 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");
30461 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");
30462 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Status");
30463 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trunc_alg=",0,"truncate method");
30464 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiE=",0,"Number of sigama from e");
30465 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiMu=",0,"Number of sigama from muon");
30466 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiPi=",0,"Number of sigama from pion");
30467 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiK=",0,"Number of sigama from k");
30468 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiP=",0,"Number of sigama from p");
30469 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)");
30470 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)");
30471 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");
30472 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");
30473 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errorPH=",0,"resolution of truncated mean ");
30474 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% ");
30475 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30476 }
30477 G__tag_memvar_reset();
30478}
30479
30480
30481 /* TExtTrack */
30482static void G__setup_memvarTExtTrack(void) {
30483 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack));
30484 { TExtTrack *p; p=(TExtTrack*)0x1000; if (p) { }
30485 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");
30486 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.");
30487 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");
30488 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");
30489 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.");
30490 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.");
30491 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.");
30492 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myTof1VolumeName=",0,"Scintillator volume name");
30493 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myTof1VolumeNumber=",0,"Scintillator volume number");
30494 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1=",0,"Time of flight");
30495 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1Path=",0,"Path of flight");
30496 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongZ=",0,"Sigma Z");
30497 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongT=",0,"Sigma along Z x R");
30498 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongX=",0,"Sigma X");
30499 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongY=",0,"Sigma Y");
30500 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1ErrorMatrix[21]=",0,"Error matrix 6x6 (x,p)");
30501 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.");
30502 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");
30503 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");
30504 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");
30505 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");
30506 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");
30507 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myTof2VolumeName=",0,"Scintillator volume name");
30508 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myTof2VolumeNumber=",0,"Scintillator volume number");
30509 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2=",0,"Time of flight");
30510 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2Path=",0,"Path of flight");
30511 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongZ=",0,"Sigma Z");
30512 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongT=",0,"Sigma along Z x R");
30513 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongX=",0,"Sigma X");
30514 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongY=",0,"Sigma Y");
30515 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2ErrorMatrix[21]=",0,"Error matrix 6x6 (x,p)");
30516 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionX=",0,"Position 2.");
30517 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionY=",0,"Position 2");
30518 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionZ=",0,"Position 2");
30519 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumX=",0,"Momentum ");
30520 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumY=",0,"Momentum ");
30521 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumZ=",0,"Momentum ");
30522 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myEmcVolumeName=",0,"Scintillator volume name");
30523 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myEmcVolumeNumber=",0,"Scintillator volume number");
30524 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPosSigmaAlongTheta=",0,(char*)NULL);
30525 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPosSigmaAlongPhi=",0,(char*)NULL);
30526 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcErrorMatrix[21]=",0,"Error matrix 6x6 (x,p)");
30527 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPath=",0,(char*)NULL);
30528 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionX=",0,"Position 2.");
30529 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionY=",0,"Position 2");
30530 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionZ=",0,"Position 2");
30531 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumX=",0,"Momentum ");
30532 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumY=",0,"Momentum ");
30533 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumZ=",0,"Momentum ");
30534 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myMucVolumeName=",0,"Scintillator volume name");
30535 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myMucVolumeNumber=",0,"Scintillator volume number");
30536 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongZ=",0,(char*)NULL);
30537 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongT=",0,(char*)NULL);
30538 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongX=",0,(char*)NULL);
30539 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongY=",0,(char*)NULL);
30540 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucErrorMatrix[21]=",0,(char*)NULL);
30541 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30542 }
30543 G__tag_memvar_reset();
30544}
30545
30546
30547 /* TMdcKalTrack */
30548static void G__setup_memvarTMdcKalTrack(void) {
30549 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack));
30550 { TMdcKalTrack *p; p=(TMdcKalTrack*)0x1000; if (p) { }
30551 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,(char*)NULL);
30552 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat[5]=",0,(char*)NULL);
30553 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat2[5]=",0,(char*)NULL);
30554 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chisq[5]=",0,(char*)NULL);
30555 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndf[5]=",0,(char*)NULL);
30556 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nlayer[5]=",0,(char*)NULL);
30557 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 ");
30558 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 ");
30559 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 ");
30560 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 ");
30561 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 ");
30562 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 ; ");
30563 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 ");
30564 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 ");
30565 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 ");
30566 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 ");
30567 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 ");
30568 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 ");
30569 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_e[5]=",0,(char*)NULL);
30570 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_e[15]=",0,(char*)NULL);
30571 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_mu[5]=",0,(char*)NULL);
30572 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_mu[15]=",0,(char*)NULL);
30573 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_k[5]=",0,(char*)NULL);
30574 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_k[15]=",0,(char*)NULL);
30575 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_p[5]=",0,(char*)NULL);
30576 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_p[15]=",0,(char*)NULL);
30577 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30578 }
30579 G__tag_memvar_reset();
30580}
30581
30582
30583 /* TDstEvent */
30584static void G__setup_memvarTDstEvent(void) {
30585 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent));
30586 { TDstEvent *p; p=(TDstEvent*)0x1000; if (p) { }
30587 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcTrackCol=",0,(char*)NULL);
30588 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_emcTrackCol=",0,"->");
30589 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcTrackCol=",0,(char*)NULL);
30590 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcTrackCol=",0,"-> ");
30591 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticTofTrackCol=",0,(char*)NULL);
30592 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tofTrackCol=",0,"->");
30593 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMucTrackCol=",0,(char*)NULL);
30594 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mucTrackCol=",0,"->");
30595 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcDedxCol=",0,(char*)NULL);
30596 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcDedxCol=",0,"->");
30597 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticExtTrackCol=",0,(char*)NULL);
30598 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_extTrackCol=",0,"->");
30599 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcKalTrackCol=",0,(char*)NULL);
30600 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcKalTrackCol=",0,"->");
30601 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30602 }
30603 G__tag_memvar_reset();
30604}
30605
30606
30607 /* TMdcMc */
30608static void G__setup_memvarTMdcMc(void) {
30609 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc));
30610 { TMdcMc *p; p=(TMdcMc*)0x1000; if (p) { }
30611 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_id=",0,(char*)NULL);
30612 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
30613 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosition=",0,(char*)NULL);
30614 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosition=",0,(char*)NULL);
30615 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosition=",0,(char*)NULL);
30616 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_driftDistance=",0,(char*)NULL);
30617 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depositEnergy=",0,(char*)NULL);
30618 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_posFlag=",0,(char*)NULL);
30619 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30620 }
30621 G__tag_memvar_reset();
30622}
30623
30624
30625 /* TEmcMc */
30626static void G__setup_memvarTEmcMc(void) {
30627 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc));
30628 { TEmcMc *p; p=(TEmcMc*)0x1000; if (p) { }
30629 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_hitEmc=",0,(char*)NULL);
30630 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_PDGCode=",0,(char*)NULL);
30631 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_PDGCharge=",0,(char*)NULL);
30632 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,(char*)NULL);
30633 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_id=",0,(char*)NULL);
30634 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
30635 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosition=",0,(char*)NULL);
30636 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosition=",0,(char*)NULL);
30637 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosition=",0,(char*)NULL);
30638 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,(char*)NULL);
30639 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,(char*)NULL);
30640 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,(char*)NULL);
30641 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depositEnergy=",0,(char*)NULL);
30642 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);
30643 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30644 }
30645 G__tag_memvar_reset();
30646}
30647
30648
30649 /* TTofMc */
30650static void G__setup_memvarTTofMc(void) {
30651 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc));
30652 { TTofMc *p; p=(TTofMc*)0x1000; if (p) { }
30653 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_id=",0,(char*)NULL);
30654 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
30655 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosition=",0,(char*)NULL);
30656 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosition=",0,(char*)NULL);
30657 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosition=",0,(char*)NULL);
30658 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,(char*)NULL);
30659 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,(char*)NULL);
30660 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,(char*)NULL);
30661 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_trackLength=",0,(char*)NULL);
30662 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_flightTime=",0,(char*)NULL);
30663 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30664 }
30665 G__tag_memvar_reset();
30666}
30667
30668
30669 /* TMucMc */
30670static void G__setup_memvarTMucMc(void) {
30671 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc));
30672 { TMucMc *p; p=(TMucMc*)0x1000; if (p) { }
30673 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_id=",0,(char*)NULL);
30674 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
30675 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosition=",0,(char*)NULL);
30676 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosition=",0,(char*)NULL);
30677 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosition=",0,(char*)NULL);
30678 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,(char*)NULL);
30679 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,(char*)NULL);
30680 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,(char*)NULL);
30681 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depositEnergy=",0,(char*)NULL);
30682 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30683 }
30684 G__tag_memvar_reset();
30685}
30686
30687
30688 /* TMcParticle */
30689static void G__setup_memvarTMcParticle(void) {
30690 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle));
30691 { TMcParticle *p; p=(TMcParticle*)0x1000; if (p) { }
30692 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);
30693 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);
30694 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);
30695 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);
30696 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);
30697 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_particleID=",0,(char*)NULL);
30698 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
30699 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_vertexIndex0=",0,(char*)NULL);
30700 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_vertexIndex1=",0,(char*)NULL);
30701 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_statusFlags=",0,(char*)NULL);
30702 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xInitialPosition=",0,(char*)NULL);
30703 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yInitialPosition=",0,(char*)NULL);
30704 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zInitialPosition=",0,(char*)NULL);
30705 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tInitialPosition=",0,(char*)NULL);
30706 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xFinalPosition=",0,(char*)NULL);
30707 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yFinalPosition=",0,(char*)NULL);
30708 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zFinalPosition=",0,(char*)NULL);
30709 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tFinalPosition=",0,(char*)NULL);
30710 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xInitialMomentum=",0,(char*)NULL);
30711 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yInitialMomentum=",0,(char*)NULL);
30712 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zInitialMomentum=",0,(char*)NULL);
30713 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eInitialMomentum=",0,(char*)NULL);
30714 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mother=",0,(char*)NULL);
30715 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);
30716 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30717 }
30718 G__tag_memvar_reset();
30719}
30720
30721
30722 /* TMcEvent */
30723static void G__setup_memvarTMcEvent(void) {
30724 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent));
30725 { TMcEvent *p; p=(TMcEvent*)0x1000; if (p) { }
30726 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcMcHitCol=",0,(char*)NULL);
30727 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcMcHitCol=",0,"-> ");
30728 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcMcHitCol=",0,(char*)NULL);
30729 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_emcMcHitCol=",0,"->");
30730 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticTofMcHitCol=",0,(char*)NULL);
30731 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tofMcHitCol=",0,"->");
30732 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMucMcHitCol=",0,(char*)NULL);
30733 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mucMcHitCol=",0,"->");
30734 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMcParticleCol=",0,(char*)NULL);
30735 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mcParticleCol=",0,"->");
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 /* TEvtHeader */
30743static void G__setup_memvarTEvtHeader(void) {
30744 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader));
30745 { TEvtHeader *p; p=(TEvtHeader*)0x1000; if (p) { }
30746 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_eventId=",0,(char*)NULL);
30747 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_runId=",0,(char*)NULL);
30748 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_time=",0,(char*)NULL);
30749 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_eventTag=",0,(char*)NULL);
30750 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_flag1=",0,(char*)NULL);
30751 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_flag2=",0,(char*)NULL);
30752 G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,4,"m_etsT1=",0,(char*)NULL);
30753 G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,4,"m_etsT2=",0,(char*)NULL);
30754 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30755 }
30756 G__tag_memvar_reset();
30757}
30758
30759
30760 /* TEvtNavigator */
30761static void G__setup_memvarTEvtNavigator(void) {
30762 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator));
30763 { TEvtNavigator *p; p=(TEvtNavigator*)0x1000; if (p) { }
30764 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");
30765 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");
30766 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");
30767 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");
30768 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30769 }
30770 G__tag_memvar_reset();
30771}
30772
30773
30774 /* TTrigData */
30775static void G__setup_memvarTTrigData(void) {
30776 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData));
30777 { TTrigData *p; p=(TTrigData*)0x1000; if (p) { }
30778 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_preScale=",0,"PreScale for bhabha events");
30779 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");
30780 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");
30781 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");
30782 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");
30783 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30784 }
30785 G__tag_memvar_reset();
30786}
30787
30788
30789 /* TTrigEvent */
30790static void G__setup_memvarTTrigEvent(void) {
30791 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent));
30792 { TTrigEvent *p; p=(TTrigEvent*)0x1000; if (p) { }
30793 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData),-1,-2,4,"s_staticTrigData=",0,(char*)NULL);
30794 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData),-1,-1,4,"m_trigData=",0,"->");
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 /* THltRaw */
30802static void G__setup_memvarTHltRaw(void) {
30803 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw));
30804 { THltRaw *p; p=(THltRaw*)0x1000; if (p) { }
30805 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30806 }
30807 G__tag_memvar_reset();
30808}
30809
30810
30811 /* THltInf */
30812static void G__setup_memvarTHltInf(void) {
30813 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf));
30814 { THltInf *p; p=(THltInf*)0x1000; if (p) { }
30815 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_evtType=",0,(char*)NULL);
30816 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_algProcess=",0,(char*)NULL);
30817 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_criTable=",0,(char*)NULL);
30818 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_verNumber=",0,(char*)NULL);
30819 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eTotal=",0,(char*)NULL);
30820 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_subNumber=",0,(char*)NULL);
30821 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_conNumber=",0,(char*)NULL);
30822 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);
30823 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);
30824 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);
30825 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);
30826 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);
30827 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30828 }
30829 G__tag_memvar_reset();
30830}
30831
30832
30833 /* TDstHltInf */
30834static void G__setup_memvarTDstHltInf(void) {
30835 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf));
30836 { TDstHltInf *p; p=(TDstHltInf*)0x1000; if (p) { }
30837 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_evtType=",0,(char*)NULL);
30838 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_algProcess=",0,(char*)NULL);
30839 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_criTable=",0,(char*)NULL);
30840 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_verNumber=",0,(char*)NULL);
30841 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eTotal=",0,(char*)NULL);
30842 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_subNumber=",0,(char*)NULL);
30843 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_conNumber=",0,(char*)NULL);
30844 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30845 }
30846 G__tag_memvar_reset();
30847}
30848
30849
30850 /* THltEvent */
30851static void G__setup_memvarTHltEvent(void) {
30852 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent));
30853 { THltEvent *p; p=(THltEvent*)0x1000; if (p) { }
30854 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticHltRawCol=",0,(char*)NULL);
30855 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_hltRawCol=",0,"->");
30856 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf),-1,-2,4,"s_staticHltInf=",0,(char*)NULL);
30857 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf),-1,-1,4,"m_hltInf=",0,"->");
30858 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf),-1,-2,4,"s_staticDstHltInf=",0,(char*)NULL);
30859 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf),-1,-1,4,"m_dstHltInf=",0,"->");
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 /* TDisTrack */
30867static void G__setup_memvarTDisTrack(void) {
30868 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack));
30869 { TDisTrack *p; p=(TDisTrack*)0x1000; if (p) { }
30870 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcTrackCol=",0,"->");
30871 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recTofTrackCol=",0,"->");
30872 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcHitCol=",0,"->");
30873 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMucTrackCol=",0,"->");
30874 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEmcShowerCol=",0,"->");
30875 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30876 }
30877 G__tag_memvar_reset();
30878}
30879
30880
30881 /* TEvtRecEvent */
30882static void G__setup_memvarTEvtRecEvent(void) {
30883 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent));
30884 { TEvtRecEvent *p; p=(TEvtRecEvent*)0x1000; if (p) { }
30885 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_tottks=",0,"total tracks");
30886 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nchrg=",0,"total charged tracks");
30887 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nneu=",0,"total neutral tracks");
30888 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");
30889 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_npi0=",0,"number of pi0'");
30890 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_neta=",0,"number of eta'");
30891 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndtag=",0,"number of dtags'");
30892 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30893 }
30894 G__tag_memvar_reset();
30895}
30896
30897
30898 /* TEvtRecTrack */
30899static void G__setup_memvarTEvtRecTrack(void) {
30900 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack));
30901 { TEvtRecTrack *p; p=(TEvtRecTrack*)0x1000; if (p) { }
30902 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,(char*)NULL);
30903 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_partId=",0,(char*)NULL);
30904 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_quality=",0,(char*)NULL);
30905 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcTrackId=",0,(char*)NULL);
30906 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcKalTrackId=",0,(char*)NULL);
30907 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcDedxId=",0,(char*)NULL);
30908 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_extTrackId=",0,(char*)NULL);
30909 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_emcShowerId=",0,(char*)NULL);
30910 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mucTrackId=",0,(char*)NULL);
30911 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);
30912 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30913 }
30914 G__tag_memvar_reset();
30915}
30916
30917
30918 /* TEvtRecPrimaryVertex */
30919static void G__setup_memvarTEvtRecPrimaryVertex(void) {
30920 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex));
30921 { TEvtRecPrimaryVertex *p; p=(TEvtRecPrimaryVertex*)0x1000; if (p) { }
30922 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_isValid=",0,(char*)NULL);
30923 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");
30924 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");
30925 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,"chi square of vertex fitting");
30926 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndof=",0,"degree of freedom ");
30927 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_fitMethod=",0,"vertex fitting algorithm ");
30928 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)");
30929 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 ");
30930 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30931 }
30932 G__tag_memvar_reset();
30933}
30934
30935
30936 /* TEvtRecVeeVertex */
30937static void G__setup_memvarTEvtRecVeeVertex(void) {
30938 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex));
30939 { TEvtRecVeeVertex *p; p=(TEvtRecVeeVertex*)0x1000; if (p) { }
30940 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_vertexId=",0,(char*)NULL);
30941 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");
30942 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,"chi square of vertex fitting");
30943 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndof=",0,"degree of freedom");
30944 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");
30945 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");
30946 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_Ew[28]=",0,"error matrix");
30947 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_pair[2]=",0,"identification of daughter particles");
30948 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nCharge=",0,"total charges of daughter particles ");
30949 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nTracks=",0,"total tracks of daughter particles");
30950 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_daughter[2]=",0,(char*)NULL);
30951 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30952 }
30953 G__tag_memvar_reset();
30954}
30955
30956
30957 /* TEvtRecPi0 */
30958static void G__setup_memvarTEvtRecPi0(void) {
30959 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0));
30960 { TEvtRecPi0 *p; p=(TEvtRecPi0*)0x1000; if (p) { }
30961 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_unconMass=",0,(char*)NULL);
30962 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chisq=",0,(char*)NULL);
30963 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPx=",0,(char*)NULL);
30964 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPy=",0,(char*)NULL);
30965 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPz=",0,(char*)NULL);
30966 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPe=",0,(char*)NULL);
30967 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPx=",0,(char*)NULL);
30968 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPy=",0,(char*)NULL);
30969 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPz=",0,(char*)NULL);
30970 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPe=",0,(char*)NULL);
30971 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_hiEnGamma=",0,(char*)NULL);
30972 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_loEnGamma=",0,(char*)NULL);
30973 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30974 }
30975 G__tag_memvar_reset();
30976}
30977
30978
30979 /* TEvtRecEtaToGG */
30980static void G__setup_memvarTEvtRecEtaToGG(void) {
30981 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG));
30982 { TEvtRecEtaToGG *p; p=(TEvtRecEtaToGG*)0x1000; if (p) { }
30983 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_unconMass=",0,(char*)NULL);
30984 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chisq=",0,(char*)NULL);
30985 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPx=",0,(char*)NULL);
30986 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPy=",0,(char*)NULL);
30987 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPz=",0,(char*)NULL);
30988 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPe=",0,(char*)NULL);
30989 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPx=",0,(char*)NULL);
30990 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPy=",0,(char*)NULL);
30991 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPz=",0,(char*)NULL);
30992 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPe=",0,(char*)NULL);
30993 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_hiEnGamma=",0,(char*)NULL);
30994 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_loEnGamma=",0,(char*)NULL);
30995 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30996 }
30997 G__tag_memvar_reset();
30998}
30999
31000
31001 /* TEvtRecDTag */
31002static void G__setup_memvarTEvtRecDTag(void) {
31003 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag));
31004 { TEvtRecDTag *p; p=(TEvtRecDTag*)0x1000; if (p) { }
31005 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_decayMode=",0,(char*)NULL);
31006 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_type=",0,(char*)NULL);
31007 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_beamE=",0,(char*)NULL);
31008 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_mass=",0,(char*)NULL);
31009 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_mBC=",0,(char*)NULL);
31010 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_deltaE=",0,(char*)NULL);
31011 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_charge=",0,(char*)NULL);
31012 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_charm=",0,(char*)NULL);
31013 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_numOfChildren=",0,(char*)NULL);
31014 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,(char*)NULL);
31015 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,(char*)NULL);
31016 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,(char*)NULL);
31017 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pe=",0,(char*)NULL);
31018 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);
31019 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);
31020 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);
31021 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);
31022 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);
31023 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);
31024 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31025 }
31026 G__tag_memvar_reset();
31027}
31028
31029
31030 /* TEvtRecObject */
31031static void G__setup_memvarTEvtRecObject(void) {
31032 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject));
31033 { TEvtRecObject *p; p=(TEvtRecObject*)0x1000; if (p) { }
31034 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent),-1,-2,4,"s_staticEvtRecEvent=",0,(char*)NULL);
31035 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent),-1,-1,4,"m_evtRecEvent=",0,"->");
31036 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecTrackCol=",0,(char*)NULL);
31037 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecTrackCol=",0,"->");
31038 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex),-1,-2,4,"s_staticEvtRecPrimaryVertex=",0,(char*)NULL);
31039 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex),-1,-1,4,"m_evtRecPrimaryVertex=",0,"->");
31040 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecVeeVertexCol=",0,(char*)NULL);
31041 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecVeeVertexCol=",0,"->");
31042 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecPi0Col=",0,(char*)NULL);
31043 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecPi0Col=",0,"->");
31044 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecEtaToGGCol=",0,(char*)NULL);
31045 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecEtaToGGCol=",0,"->");
31046 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecDTagCol=",0,(char*)NULL);
31047 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecDTagCol=",0,"->");
31048 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31049 }
31050 G__tag_memvar_reset();
31051}
31052
31053
31054 /* TMcHitTof */
31055static void G__setup_memvarTMcHitTof(void) {
31056 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof));
31057 { TMcHitTof *p; p=(TMcHitTof*)0x1000; if (p) { }
31058 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
31059 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_g4Index=",0,(char*)NULL);
31060 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_partId=",0,(char*)NULL);
31061 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_scinNb=",0,(char*)NULL);
31062 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_edep=",0,(char*)NULL);
31063 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_stepL=",0,(char*)NULL);
31064 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_trackL=",0,(char*)NULL);
31065 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3),-1,-1,4,"m_pos=",0,(char*)NULL);
31066 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,(char*)NULL);
31067 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_deltaT=",0,(char*)NULL);
31068 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3),-1,-1,4,"m_pDirection=",0,(char*)NULL);
31069 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3),-1,-1,4,"m_momentum=",0,(char*)NULL);
31070 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_charge=",0,(char*)NULL);
31071 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31072 }
31073 G__tag_memvar_reset();
31074}
31075
31076
31077 /* TMcHitMdc */
31078static void G__setup_memvarTMcHitMdc(void) {
31079 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc));
31080 { TMcHitMdc *p; p=(TMcHitMdc*)0x1000; if (p) { }
31081 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"trackID=",0,(char*)NULL);
31082 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"layerNo=",0,(char*)NULL);
31083 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"cellNo=",0,(char*)NULL);
31084 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"edep=",0,(char*)NULL);
31085 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3),-1,-1,4,"pos=",0,(char*)NULL);
31086 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"driftD=",0,(char*)NULL);
31087 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"driftT=",0,(char*)NULL);
31088 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"globalT=",0,(char*)NULL);
31089 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"theta=",0,(char*)NULL);
31090 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"enterAngle=",0,(char*)NULL);
31091 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"posFlag=",0,(char*)NULL);
31092 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31093 }
31094 G__tag_memvar_reset();
31095}
31096
31097
31098 /* TMcDigiEmc */
31099static void G__setup_memvarTMcDigiEmc(void) {
31100 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc));
31101 { TMcDigiEmc *p; p=(TMcDigiEmc*)0x1000; if (p) { }
31102 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_partId=",0,(char*)NULL);
31103 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nTheta=",0,(char*)NULL);
31104 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nPhi=",0,(char*)NULL);
31105 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,(char*)NULL);
31106 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,(char*)NULL);
31107 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
31108 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31109 }
31110 G__tag_memvar_reset();
31111}
31112
31113
31114 /* TMcHitEvent */
31115static void G__setup_memvarTMcHitEvent(void) {
31116 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent));
31117 { TMcHitEvent *p; p=(TMcHitEvent*)0x1000; if (p) { }
31118 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tTofMcHitCol=",0,"->");
31119 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tMdcMcHitCol=",0,"->");
31120 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tEmcMcDigiCol=",0,"->");
31121 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_beamTime=",0,(char*)NULL);
31122 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31123 }
31124 G__tag_memvar_reset();
31125}
31126
31127
31128 /* TBossFullEvent */
31129static void G__setup_memvarTBossFullEvent(void) {
31130 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent));
31131 { TBossFullEvent *p; p=(TBossFullEvent*)0x1000; if (p) { }
31132 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);
31133 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);
31134 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);
31135 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);
31136 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);
31137 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);
31138 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);
31139 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);
31140 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_mask=",0,(char*)NULL);
31141 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,"->");
31142 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,"->");
31143 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,"->");
31144 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,"->");
31145 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,"->");
31146 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,"->");
31147 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,"->");
31148 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,"->");
31149 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31150 }
31151 G__tag_memvar_reset();
31152}
31153
31154extern "C" void G__cpp_setup_memvarRootEventData_rootcint() {
31155}
31156/***********************************************************
31157************************************************************
31158************************************************************
31159************************************************************
31160************************************************************
31161************************************************************
31162************************************************************
31163***********************************************************/
31164
31165/*********************************************************
31166* Member function information setup for each class
31167*********************************************************/
31168static void G__setup_memfuncTJobInfo(void) {
31169 /* TJobInfo */
31170 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo));
31171 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);
31172 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);
31173 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);
31174 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);
31175 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);
31176 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);
31177 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);
31178 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);
31179 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);
31180 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);
31181 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);
31182 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);
31183 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);
31184 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);
31185 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);
31186 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31187 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31188 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);
31189 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);
31190 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);
31191 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);
31192 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);
31193 // automatic copy constructor
31194 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);
31195 // automatic destructor
31196 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);
31197 // automatic assignment operator
31198 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);
31199 G__tag_memfunc_reset();
31200}
31201
31202static void G__setup_memfuncTRawData(void) {
31203 /* TRawData */
31204 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData));
31205 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);
31206 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_200_0_2, 121, -1, -1, 0, 3, 1, 1, 0,
31207"h - 'UInt_t' 0 - id h - 'UInt_t' 0 '0' time "
31208"h - 'UInt_t' 0 '0' charge", (char*)NULL, (void*) NULL, 0);
31209 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);
31210 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);
31211 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);
31212 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);
31213 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);
31214 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);
31215 G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_200_0_9, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31216 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);
31217 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);
31218 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);
31219 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);
31220 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);
31221 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31222 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31223 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);
31224 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);
31225 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);
31226 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);
31227 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);
31228 // automatic copy constructor
31229 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);
31230 // automatic destructor
31231 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);
31232 // automatic assignment operator
31233 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);
31234 G__tag_memfunc_reset();
31235}
31236
31237static void G__setup_memfuncTMdcDigi(void) {
31238 /* TMdcDigi */
31239 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi));
31240 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);
31241 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);
31242 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);
31243 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);
31244 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);
31245 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);
31246 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);
31247 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);
31248 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31249 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31250 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);
31251 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);
31252 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);
31253 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);
31254 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);
31255 // automatic copy constructor
31256 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);
31257 // automatic destructor
31258 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);
31259 // automatic assignment operator
31260 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);
31261 G__tag_memfunc_reset();
31262}
31263
31264static void G__setup_memfuncTEmcDigi(void) {
31265 /* TEmcDigi */
31266 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi));
31267 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);
31268 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);
31269 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);
31270 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);
31271 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);
31272 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);
31273 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);
31274 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);
31275 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31276 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31277 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);
31278 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);
31279 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);
31280 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);
31281 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);
31282 // automatic copy constructor
31283 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);
31284 // automatic destructor
31285 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);
31286 // automatic assignment operator
31287 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);
31288 G__tag_memfunc_reset();
31289}
31290
31291static void G__setup_memfuncTTofDigi(void) {
31292 /* TTofDigi */
31293 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi));
31294 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);
31295 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);
31296 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);
31297 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);
31298 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);
31299 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);
31300 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);
31301 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);
31302 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31303 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31304 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);
31305 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);
31306 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);
31307 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);
31308 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);
31309 // automatic copy constructor
31310 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);
31311 // automatic destructor
31312 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);
31313 // automatic assignment operator
31314 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);
31315 G__tag_memfunc_reset();
31316}
31317
31318static void G__setup_memfuncTMucDigi(void) {
31319 /* TMucDigi */
31320 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi));
31321 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);
31322 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);
31323 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);
31324 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);
31325 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);
31326 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);
31327 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31328 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31329 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);
31330 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);
31331 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);
31332 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);
31333 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);
31334 // automatic copy constructor
31335 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);
31336 // automatic destructor
31337 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);
31338 // automatic assignment operator
31339 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);
31340 G__tag_memfunc_reset();
31341}
31342
31343static void G__setup_memfuncTLumiDigi(void) {
31344 /* TLumiDigi */
31345 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi));
31346 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);
31347 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);
31348 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);
31349 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);
31350 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);
31351 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);
31352 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);
31353 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);
31354 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31355 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31356 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);
31357 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);
31358 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);
31359 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);
31360 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);
31361 // automatic copy constructor
31362 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);
31363 // automatic destructor
31364 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);
31365 // automatic assignment operator
31366 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);
31367 G__tag_memfunc_reset();
31368}
31369
31370static void G__setup_memfuncTDigiEvent(void) {
31371 /* TDigiEvent */
31372 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent));
31373 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);
31374 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);
31375 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);
31376 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);
31377 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);
31378 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);
31379 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);
31380 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);
31381 G__memfunc_setup("clearMdcDigiCol",1462,G__RootEventData_rootcint_206_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31382 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);
31383 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);
31384 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);
31385 G__memfunc_setup("clearEmcDigiCol",1463,G__RootEventData_rootcint_206_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31386 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);
31387 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);
31388 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);
31389 G__memfunc_setup("clearTofDigiCol",1483,G__RootEventData_rootcint_206_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31390 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);
31391 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);
31392 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);
31393 G__memfunc_setup("clearMucDigiCol",1479,G__RootEventData_rootcint_206_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31394 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);
31395 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);
31396 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);
31397 G__memfunc_setup("clearLumiDigiCol",1593,G__RootEventData_rootcint_206_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31398 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);
31399 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);
31400 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);
31401 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);
31402 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);
31403 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31404 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31405 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);
31406 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);
31407 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);
31408 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);
31409 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);
31410 // automatic copy constructor
31411 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);
31412 // automatic destructor
31413 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);
31414 // automatic assignment operator
31415 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);
31416 G__tag_memfunc_reset();
31417}
31418
31419static void G__setup_memfuncTRecMdcTrack(void) {
31420 /* TRecMdcTrack */
31421 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack));
31422 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);
31423 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);
31424 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);
31425 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);
31426 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);
31427 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);
31428 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);
31429 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);
31430 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);
31431 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);
31432 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);
31433 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);
31434 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);
31435 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);
31436 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);
31437 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);
31438 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);
31439 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);
31440 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);
31441 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);
31442 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);
31443 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);
31444 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);
31445 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);
31446 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);
31447 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);
31448 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);
31449 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);
31450 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);
31451 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);
31452 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);
31453 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);
31454 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);
31455 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);
31456 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);
31457 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);
31458 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);
31459 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);
31460 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);
31461 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);
31462 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);
31463 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);
31464 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);
31465 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);
31466 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);
31467 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31468 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31469 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);
31470 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);
31471 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);
31472 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);
31473 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);
31474 // automatic copy constructor
31475 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);
31476 // automatic destructor
31477 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);
31478 // automatic assignment operator
31479 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);
31480 G__tag_memfunc_reset();
31481}
31482
31483static void G__setup_memfuncTRecMdcKalTrack(void) {
31484 /* TRecMdcKalTrack */
31485 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack));
31486 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);
31487 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);
31488 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);
31489 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);
31490 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);
31491 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);
31492 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);
31493 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);
31494 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);
31495 G__memfunc_setup("getStat",732,G__RootEventData_rootcint_208_0_10, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 9,
31496"i - 'Int_t' 0 - i i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31497 G__memfunc_setup("getChisq",824,G__RootEventData_rootcint_208_0_11, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31498"i - 'Int_t' 0 - i i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31499 G__memfunc_setup("getNdf",600,G__RootEventData_rootcint_208_0_12, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 9,
31500"i - 'Int_t' 0 - i i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31501 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);
31502 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);
31503 G__memfunc_setup("getZError",932,G__RootEventData_rootcint_208_0_15, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31504"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31505 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);
31506 G__memfunc_setup("getZErrorE",1001,G__RootEventData_rootcint_208_0_17, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31507"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31508 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);
31509 G__memfunc_setup("getZErrorMu",1126,G__RootEventData_rootcint_208_0_19, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31510"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31511 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);
31512 G__memfunc_setup("getZErrorK",1007,G__RootEventData_rootcint_208_0_21, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31513"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31514 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);
31515 G__memfunc_setup("getZErrorP",1012,G__RootEventData_rootcint_208_0_23, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31516"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31517 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);
31518 G__memfunc_setup("getFError",912,G__RootEventData_rootcint_208_0_25, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31519"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31520 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);
31521 G__memfunc_setup("getFErrorE",981,G__RootEventData_rootcint_208_0_27, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31522"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31523 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);
31524 G__memfunc_setup("getFErrorMu",1106,G__RootEventData_rootcint_208_0_29, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31525"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31526 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);
31527 G__memfunc_setup("getFErrorK",987,G__RootEventData_rootcint_208_0_31, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31528"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31529 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);
31530 G__memfunc_setup("getFErrorP",992,G__RootEventData_rootcint_208_0_33, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31531"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31532 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);
31533 G__memfunc_setup("getLError",918,G__RootEventData_rootcint_208_0_35, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31534"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31535 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);
31536 G__memfunc_setup("getLErrorE",987,G__RootEventData_rootcint_208_0_37, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31537"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31538 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);
31539 G__memfunc_setup("getLErrorMu",1112,G__RootEventData_rootcint_208_0_39, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31540"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31541 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);
31542 G__memfunc_setup("getLErrorK",993,G__RootEventData_rootcint_208_0_41, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31543"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31544 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);
31545 G__memfunc_setup("getLErrorP",998,G__RootEventData_rootcint_208_0_43, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31546"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31547 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);
31548 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);
31549 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);
31550 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);
31551 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);
31552 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);
31553 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);
31554 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);
31555 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);
31556 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);
31557 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);
31558 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);
31559 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);
31560 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);
31561 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);
31562 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);
31563 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);
31564 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);
31565 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);
31566 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);
31567 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);
31568 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);
31569 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);
31570 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);
31571 G__memfunc_setup("setStat",744,G__RootEventData_rootcint_208_0_68, 121, -1, -1, 0, 3, 1, 1, 0,
31572"i - 'Int_t' 10 - stat i - 'Int_t' 0 - i "
31573"i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31574 G__memfunc_setup("setChisq",836,G__RootEventData_rootcint_208_0_69, 121, -1, -1, 0, 3, 1, 1, 0,
31575"d - 'Double_t' 10 - chisq i - 'Int_t' 0 - i "
31576"i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31577 G__memfunc_setup("setNdf",612,G__RootEventData_rootcint_208_0_70, 121, -1, -1, 0, 3, 1, 1, 0,
31578"i - 'Int_t' 10 - ndf i - 'Int_t' 0 - i "
31579"i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31580 G__memfunc_setup("setNseg",729,G__RootEventData_rootcint_208_0_71, 121, -1, -1, 0, 2, 1, 1, 0,
31581"i - 'Int_t' 10 - nSeg i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31582 G__memfunc_setup("setNlayer",951,G__RootEventData_rootcint_208_0_72, 121, -1, -1, 0, 2, 1, 1, 0,
31583"i - 'Int_t' 10 - nlayer i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31584 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);
31585 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);
31586 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);
31587 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);
31588 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);
31589 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);
31590 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);
31591 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);
31592 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);
31593 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);
31594 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);
31595 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);
31596 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);
31597 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);
31598 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);
31599 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);
31600 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);
31601 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);
31602 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);
31603 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);
31604 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);
31605 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);
31606 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);
31607 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);
31608 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);
31609 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);
31610 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);
31611 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);
31612 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);
31613 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);
31614 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);
31615 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);
31616 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);
31617 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);
31618 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);
31619 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);
31620 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);
31621 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);
31622 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);
31623 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);
31624 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);
31625 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);
31626 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);
31627 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);
31628 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);
31629 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);
31630 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);
31631 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);
31632 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);
31633 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);
31634 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);
31635 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);
31636 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31637 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31638 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);
31639 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);
31640 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);
31641 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);
31642 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);
31643 // automatic copy constructor
31644 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);
31645 // automatic destructor
31646 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);
31647 // automatic assignment operator
31648 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);
31649 G__tag_memfunc_reset();
31650}
31651
31652static void G__setup_memfuncTRecMdcHit(void) {
31653 /* TRecMdcHit */
31654 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit));
31655 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);
31656 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);
31657 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);
31658 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);
31659 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);
31660 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);
31661 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);
31662 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);
31663 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);
31664 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);
31665 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);
31666 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);
31667 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);
31668 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);
31669 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);
31670 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);
31671 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);
31672 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);
31673 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);
31674 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);
31675 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);
31676 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);
31677 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);
31678 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);
31679 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);
31680 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);
31681 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);
31682 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);
31683 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);
31684 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);
31685 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);
31686 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);
31687 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);
31688 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);
31689 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);
31690 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);
31691 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);
31692 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);
31693 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);
31694 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);
31695 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);
31696 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);
31697 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);
31698 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31699 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31700 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);
31701 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);
31702 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);
31703 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);
31704 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);
31705 // automatic copy constructor
31706 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);
31707 // automatic destructor
31708 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);
31709 // automatic assignment operator
31710 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);
31711 G__tag_memfunc_reset();
31712}
31713
31714static void G__setup_memfuncTTofTrack(void) {
31715 /* TTofTrack */
31716 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack));
31717 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);
31718 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);
31719 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);
31720 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);
31721 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);
31722 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);
31723 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);
31724 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);
31725 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);
31726 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);
31727 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);
31728 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);
31729 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);
31730 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);
31731 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);
31732 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);
31733 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);
31734 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);
31735 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);
31736 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);
31737 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);
31738 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);
31739 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);
31740 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);
31741 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);
31742 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);
31743 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);
31744 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);
31745 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);
31746 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);
31747 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);
31748 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);
31749 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);
31750 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);
31751 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);
31752 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);
31753 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);
31754 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);
31755 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);
31756 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);
31757 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);
31758 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);
31759 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);
31760 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);
31761 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);
31762 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);
31763 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);
31764 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);
31765 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);
31766 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);
31767 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);
31768 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);
31769 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);
31770 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);
31771 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);
31772 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);
31773 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);
31774 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);
31775 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);
31776 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);
31777 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);
31778 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);
31779 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);
31780 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);
31781 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);
31782 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);
31783 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);
31784 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);
31785 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);
31786 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);
31787 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);
31788 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);
31789 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);
31790 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);
31791 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);
31792 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);
31793 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);
31794 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);
31795 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);
31796 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);
31797 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);
31798 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);
31799 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31800 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31801 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);
31802 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);
31803 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);
31804 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);
31805 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);
31806 // automatic copy constructor
31807 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);
31808 // automatic destructor
31809 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);
31810 // automatic assignment operator
31811 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);
31812 G__tag_memfunc_reset();
31813}
31814
31815static void G__setup_memfuncTRecTofTrack(void) {
31816 /* TRecTofTrack */
31817 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack));
31818 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);
31819 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);
31820 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);
31821 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);
31822 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);
31823 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);
31824 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);
31825 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);
31826 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);
31827 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);
31828 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);
31829 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);
31830 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);
31831 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);
31832 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);
31833 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);
31834 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);
31835 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);
31836 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);
31837 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);
31838 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);
31839 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);
31840 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);
31841 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);
31842 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);
31843 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);
31844 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);
31845 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);
31846 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);
31847 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);
31848 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);
31849 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);
31850 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);
31851 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);
31852 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);
31853 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);
31854 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);
31855 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);
31856 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);
31857 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);
31858 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);
31859 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);
31860 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);
31861 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);
31862 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);
31863 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);
31864 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);
31865 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);
31866 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);
31867 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);
31868 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);
31869 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);
31870 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);
31871 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);
31872 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);
31873 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);
31874 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);
31875 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);
31876 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);
31877 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);
31878 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);
31879 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);
31880 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);
31881 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);
31882 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);
31883 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);
31884 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);
31885 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);
31886 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);
31887 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);
31888 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);
31889 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);
31890 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);
31891 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);
31892 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);
31893 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);
31894 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);
31895 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);
31896 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);
31897 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);
31898 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);
31899 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);
31900 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);
31901 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31902 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31903 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);
31904 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);
31905 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);
31906 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);
31907 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);
31908 // automatic copy constructor
31909 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);
31910 // automatic destructor
31911 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);
31912 // automatic assignment operator
31913 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);
31914 G__tag_memfunc_reset();
31915}
31916
31917static void G__setup_memfuncTRecEmcHit(void) {
31918 /* TRecEmcHit */
31919 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit));
31920 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);
31921 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);
31922 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);
31923 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);
31924 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);
31925 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);
31926 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);
31927 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);
31928 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);
31929 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);
31930 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);
31931 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);
31932 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31933 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31934 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);
31935 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);
31936 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);
31937 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);
31938 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);
31939 // automatic copy constructor
31940 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);
31941 // automatic destructor
31942 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);
31943 // automatic assignment operator
31944 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);
31945 G__tag_memfunc_reset();
31946}
31947
31948static void G__setup_memfuncTRecEmcCluster(void) {
31949 /* TRecEmcCluster */
31950 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster));
31951 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);
31952 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);
31953 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);
31954 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);
31955 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);
31956 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);
31957 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);
31958 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);
31959 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);
31960 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);
31961 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);
31962 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);
31963 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);
31964 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);
31965 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31966 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31967 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);
31968 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);
31969 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);
31970 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);
31971 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);
31972 // automatic copy constructor
31973 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);
31974 // automatic destructor
31975 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);
31976 // automatic assignment operator
31977 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);
31978 G__tag_memfunc_reset();
31979}
31980
31981static void G__setup_memfuncTRecEmcShower(void) {
31982 /* TRecEmcShower */
31983 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower));
31984 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);
31985 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);
31986 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);
31987 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);
31988 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);
31989 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);
31990 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);
31991 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);
31992 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);
31993 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);
31994 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);
31995 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);
31996 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);
31997 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);
31998 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);
31999 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);
32000 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);
32001 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);
32002 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);
32003 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);
32004 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);
32005 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);
32006 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);
32007 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);
32008 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);
32009 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);
32010 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);
32011 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);
32012 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);
32013 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);
32014 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);
32015 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);
32016 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);
32017 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);
32018 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);
32019 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);
32020 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);
32021 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);
32022 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);
32023 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);
32024 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);
32025 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);
32026 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);
32027 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);
32028 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);
32029 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);
32030 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);
32031 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);
32032 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);
32033 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);
32034 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);
32035 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);
32036 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);
32037 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);
32038 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);
32039 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);
32040 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);
32041 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);
32042 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);
32043 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);
32044 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);
32045 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);
32046 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);
32047 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);
32048 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);
32049 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32050 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32051 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);
32052 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);
32053 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);
32054 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);
32055 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);
32056 // automatic copy constructor
32057 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);
32058 // automatic destructor
32059 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);
32060 // automatic assignment operator
32061 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);
32062 G__tag_memfunc_reset();
32063}
32064
32065static void G__setup_memfuncTRecMucTrack(void) {
32066 /* TRecMucTrack */
32067 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack));
32068 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);
32069 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);
32070 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);
32071 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);
32072 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);
32073 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);
32074 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);
32075 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);
32076 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);
32077 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);
32078 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);
32079 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);
32080 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);
32081 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);
32082 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);
32083 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);
32084 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);
32085 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);
32086 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);
32087 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);
32088 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);
32089 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);
32090 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);
32091 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);
32092 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);
32093 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);
32094 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);
32095 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);
32096 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);
32097 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);
32098 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);
32099 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);
32100 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);
32101 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);
32102 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);
32103 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);
32104 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);
32105 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);
32106 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);
32107 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);
32108 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);
32109 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);
32110 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);
32111 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);
32112 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);
32113 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);
32114 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);
32115 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);
32116 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);
32117 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);
32118 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);
32119 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);
32120 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);
32121 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);
32122 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);
32123 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);
32124 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);
32125 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);
32126 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);
32127 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);
32128 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);
32129 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);
32130 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);
32131 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);
32132 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);
32133 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);
32134 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);
32135 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);
32136 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);
32137 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);
32138 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);
32139 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);
32140 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);
32141 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);
32142 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);
32143 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32144 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32145 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);
32146 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);
32147 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);
32148 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);
32149 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);
32150 // automatic copy constructor
32151 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);
32152 // automatic destructor
32153 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);
32154 // automatic assignment operator
32155 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);
32156 G__tag_memfunc_reset();
32157}
32158
32159static void G__setup_memfuncTRecMdcDedx(void) {
32160 /* TRecMdcDedx */
32161 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx));
32162 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);
32163 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);
32164 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);
32165 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);
32166 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);
32167 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);
32168 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);
32169 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);
32170 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);
32171 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);
32172 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);
32173 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);
32174 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);
32175 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);
32176 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);
32177 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);
32178 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);
32179 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);
32180 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);
32181 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);
32182 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);
32183 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);
32184 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);
32185 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);
32186 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);
32187 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);
32188 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);
32189 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);
32190 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);
32191 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);
32192 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);
32193 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);
32194 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);
32195 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);
32196 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);
32197 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);
32198 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);
32199 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);
32200 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);
32201 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);
32202 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);
32203 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);
32204 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);
32205 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);
32206 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);
32207 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);
32208 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);
32209 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);
32210 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);
32211 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);
32212 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);
32213 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);
32214 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);
32215 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);
32216 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);
32217 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);
32218 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32219 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32220 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);
32221 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);
32222 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);
32223 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);
32224 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);
32225 // automatic copy constructor
32226 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);
32227 // automatic destructor
32228 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);
32229 // automatic assignment operator
32230 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);
32231 G__tag_memfunc_reset();
32232}
32233
32234static void G__setup_memfuncTRecMdcDedxHit(void) {
32235 /* TRecMdcDedxHit */
32236 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit));
32237 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);
32238 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);
32239 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);
32240 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);
32241 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);
32242 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);
32243 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);
32244 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);
32245 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);
32246 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);
32247 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);
32248 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);
32249 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);
32250 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);
32251 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);
32252 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);
32253 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);
32254 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);
32255 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);
32256 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);
32257 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);
32258 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);
32259 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32260 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32261 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);
32262 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);
32263 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);
32264 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);
32265 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);
32266 // automatic copy constructor
32267 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);
32268 // automatic destructor
32269 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);
32270 // automatic assignment operator
32271 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);
32272 G__tag_memfunc_reset();
32273}
32274
32275static void G__setup_memfuncTRecExtTrack(void) {
32276 /* TRecExtTrack */
32277 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack));
32278 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);
32279 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);
32280 G__memfunc_setup("SetTof1PositionX",1587,G__RootEventData_rootcint_460_0_3, 121, -1, -1, 0, 2, 1, 1, 0,
32281"d - 'Double_t' 10 - Tof1PositionX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32282 G__memfunc_setup("SetTof1PositionY",1588,G__RootEventData_rootcint_460_0_4, 121, -1, -1, 0, 2, 1, 1, 0,
32283"d - 'Double_t' 10 - Tof1PositionY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32284 G__memfunc_setup("SetTof1PositionZ",1589,G__RootEventData_rootcint_460_0_5, 121, -1, -1, 0, 2, 1, 1, 0,
32285"d - 'Double_t' 10 - Tof1PositionZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32286 G__memfunc_setup("SetTof1MomentumX",1584,G__RootEventData_rootcint_460_0_6, 121, -1, -1, 0, 2, 1, 1, 0,
32287"d - 'Double_t' 10 - Tof1MomentumX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32288 G__memfunc_setup("SetTof1MomentumY",1585,G__RootEventData_rootcint_460_0_7, 121, -1, -1, 0, 2, 1, 1, 0,
32289"d - 'Double_t' 10 - Tof1MomentumY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32290 G__memfunc_setup("SetTof1MomentumZ",1586,G__RootEventData_rootcint_460_0_8, 121, -1, -1, 0, 2, 1, 1, 0,
32291"d - 'Double_t' 10 - Tof1MomentumZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32292 G__memfunc_setup("SetTof1VolumeName",1663,G__RootEventData_rootcint_460_0_9, 121, -1, -1, 0, 2, 1, 1, 0,
32293"u 'TString' - 10 - Tof1VolumeName i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32294 G__memfunc_setup("SetTof1VolumeNumber",1895,G__RootEventData_rootcint_460_0_10, 121, -1, -1, 0, 2, 1, 1, 0,
32295"i - 'Int_t' 10 - Tof1VolumeNumber i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32296 G__memfunc_setup("SetTof1",646,G__RootEventData_rootcint_460_0_11, 121, -1, -1, 0, 2, 1, 1, 0,
32297"d - 'Double_t' 10 - Tof1 i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32298 G__memfunc_setup("SetTof1Path",1043,G__RootEventData_rootcint_460_0_12, 121, -1, -1, 0, 2, 1, 1, 0,
32299"d - 'Double_t' 10 - Tof1Path i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32300 G__memfunc_setup("SetTof1PosSigmaAlongZ",2036,G__RootEventData_rootcint_460_0_13, 121, -1, -1, 0, 2, 1, 1, 0,
32301"d - 'Double_t' 10 - Tof1PosSigmaAlongZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32302 G__memfunc_setup("SetTof1PosSigmaAlongT",2030,G__RootEventData_rootcint_460_0_14, 121, -1, -1, 0, 2, 1, 1, 0,
32303"d - 'Double_t' 10 - Tof1PosSigmaAlongT i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32304 G__memfunc_setup("SetTof1PosSigmaAlongX",2034,G__RootEventData_rootcint_460_0_15, 121, -1, -1, 0, 2, 1, 1, 0,
32305"d - 'Double_t' 10 - Tof1PosSigmaAlongX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32306 G__memfunc_setup("SetTof1PosSigmaAlongY",2035,G__RootEventData_rootcint_460_0_16, 121, -1, -1, 0, 2, 1, 1, 0,
32307"d - 'Double_t' 10 - Tof1PosSigmaAlongY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32308 G__memfunc_setup("SetTof1ErrorMatrix",1797,G__RootEventData_rootcint_460_0_17, 121, -1, -1, 0, 2, 1, 1, 0,
32309"D - 'Double_t' 12 - Tof1ErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32310 G__memfunc_setup("SetTof2PositionX",1588,G__RootEventData_rootcint_460_0_18, 121, -1, -1, 0, 2, 1, 1, 0,
32311"d - 'Double_t' 10 - Tof2PositionX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32312 G__memfunc_setup("SetTof2PositionY",1589,G__RootEventData_rootcint_460_0_19, 121, -1, -1, 0, 2, 1, 1, 0,
32313"d - 'Double_t' 10 - Tof2PositionY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32314 G__memfunc_setup("SetTof2PositionZ",1590,G__RootEventData_rootcint_460_0_20, 121, -1, -1, 0, 2, 1, 1, 0,
32315"d - 'Double_t' 10 - Tof2PositionZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32316 G__memfunc_setup("SetTof2MomentumX",1585,G__RootEventData_rootcint_460_0_21, 121, -1, -1, 0, 2, 1, 1, 0,
32317"d - 'Double_t' 10 - Tof2MomentumX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32318 G__memfunc_setup("SetTof2MomentumY",1586,G__RootEventData_rootcint_460_0_22, 121, -1, -1, 0, 2, 1, 1, 0,
32319"d - 'Double_t' 10 - Tof2MomentumY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32320 G__memfunc_setup("SetTof2MomentumZ",1587,G__RootEventData_rootcint_460_0_23, 121, -1, -1, 0, 2, 1, 1, 0,
32321"d - 'Double_t' 10 - Tof2MomentumZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32322 G__memfunc_setup("SetTof2VolumeName",1664,G__RootEventData_rootcint_460_0_24, 121, -1, -1, 0, 2, 1, 1, 0,
32323"u 'TString' - 10 - Tof2VolumeName i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32324 G__memfunc_setup("SetTof2VolumeNumber",1896,G__RootEventData_rootcint_460_0_25, 121, -1, -1, 0, 2, 1, 1, 0,
32325"i - 'Int_t' 10 - Tof2VolumeNumber i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32326 G__memfunc_setup("SetTof2",647,G__RootEventData_rootcint_460_0_26, 121, -1, -1, 0, 2, 1, 1, 0,
32327"d - 'Double_t' 10 - Tof2 i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32328 G__memfunc_setup("SetTof2Path",1044,G__RootEventData_rootcint_460_0_27, 121, -1, -1, 0, 2, 1, 1, 0,
32329"d - 'Double_t' 10 - Tof2Path i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32330 G__memfunc_setup("SetTof2PosSigmaAlongZ",2037,G__RootEventData_rootcint_460_0_28, 121, -1, -1, 0, 2, 1, 1, 0,
32331"d - 'Double_t' 10 - Tof2PosSigmaAlongZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32332 G__memfunc_setup("SetTof2PosSigmaAlongT",2031,G__RootEventData_rootcint_460_0_29, 121, -1, -1, 0, 2, 1, 1, 0,
32333"d - 'Double_t' 10 - Tof2PosSigmaAlongT i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32334 G__memfunc_setup("SetTof2PosSigmaAlongX",2035,G__RootEventData_rootcint_460_0_30, 121, -1, -1, 0, 2, 1, 1, 0,
32335"d - 'Double_t' 10 - Tof2PosSigmaAlongX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32336 G__memfunc_setup("SetTof2PosSigmaAlongY",2036,G__RootEventData_rootcint_460_0_31, 121, -1, -1, 0, 2, 1, 1, 0,
32337"d - 'Double_t' 10 - Tof2PosSigmaAlongY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32338 G__memfunc_setup("SetTof2ErrorMatrix",1798,G__RootEventData_rootcint_460_0_32, 121, -1, -1, 0, 2, 1, 1, 0,
32339"D - 'Double_t' 12 - Tof2ErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32340 G__memfunc_setup("SetEmcPositionX",1518,G__RootEventData_rootcint_460_0_33, 121, -1, -1, 0, 2, 1, 1, 0,
32341"d - 'Double_t' 10 - EmcPositionX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32342 G__memfunc_setup("SetEmcPositionY",1519,G__RootEventData_rootcint_460_0_34, 121, -1, -1, 0, 2, 1, 1, 0,
32343"d - 'Double_t' 10 - EmcPositionY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32344 G__memfunc_setup("SetEmcPositionZ",1520,G__RootEventData_rootcint_460_0_35, 121, -1, -1, 0, 2, 1, 1, 0,
32345"d - 'Double_t' 10 - EmcPositionZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32346 G__memfunc_setup("SetEmcMomentumX",1515,G__RootEventData_rootcint_460_0_36, 121, -1, -1, 0, 2, 1, 1, 0,
32347"d - 'Double_t' 10 - EmcMomentumX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32348 G__memfunc_setup("SetEmcMomentumY",1516,G__RootEventData_rootcint_460_0_37, 121, -1, -1, 0, 2, 1, 1, 0,
32349"d - 'Double_t' 10 - EmcMomentumY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32350 G__memfunc_setup("SetEmcMomentumZ",1517,G__RootEventData_rootcint_460_0_38, 121, -1, -1, 0, 2, 1, 1, 0,
32351"d - 'Double_t' 10 - EmcMomentumZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32352 G__memfunc_setup("SetEmcVolumeName",1594,G__RootEventData_rootcint_460_0_39, 121, -1, -1, 0, 2, 1, 1, 0,
32353"u 'TString' - 10 - EmcVolumeName i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32354 G__memfunc_setup("SetEmcVolumeNumber",1826,G__RootEventData_rootcint_460_0_40, 121, -1, -1, 0, 2, 1, 1, 0,
32355"i - 'Int_t' 10 - EmcVolumeNumber i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32356 G__memfunc_setup("SetEmcPosSigmaAlongTheta",2379,G__RootEventData_rootcint_460_0_41, 121, -1, -1, 0, 2, 1, 1, 0,
32357"d - 'Double_t' 10 - EmcPosSigmaAlongTheta i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32358 G__memfunc_setup("SetEmcPosSigmaAlongPhi",2166,G__RootEventData_rootcint_460_0_42, 121, -1, -1, 0, 2, 1, 1, 0,
32359"d - 'Double_t' 10 - EmcPosSigmaAlongPhi i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32360 G__memfunc_setup("SetEmcErrorMatrix",1728,G__RootEventData_rootcint_460_0_43, 121, -1, -1, 0, 2, 1, 1, 0,
32361"D - 'Double_t' 12 - EmcErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32362 G__memfunc_setup("SetEmcPath",974,G__RootEventData_rootcint_460_0_44, 121, -1, -1, 0, 2, 1, 1, 0,
32363"d - 'Double_t' 0 - path i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32364 G__memfunc_setup("SetMucPositionX",1534,G__RootEventData_rootcint_460_0_45, 121, -1, -1, 0, 2, 1, 1, 0,
32365"d - 'Double_t' 10 - MucPositionX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32366 G__memfunc_setup("SetMucPositionY",1535,G__RootEventData_rootcint_460_0_46, 121, -1, -1, 0, 2, 1, 1, 0,
32367"d - 'Double_t' 10 - MucPositionY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32368 G__memfunc_setup("SetMucPositionZ",1536,G__RootEventData_rootcint_460_0_47, 121, -1, -1, 0, 2, 1, 1, 0,
32369"d - 'Double_t' 10 - MucPositionZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32370 G__memfunc_setup("SetMucMomentumX",1531,G__RootEventData_rootcint_460_0_48, 121, -1, -1, 0, 2, 1, 1, 0,
32371"d - 'Double_t' 10 - MucMomentumX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32372 G__memfunc_setup("SetMucMomentumY",1532,G__RootEventData_rootcint_460_0_49, 121, -1, -1, 0, 2, 1, 1, 0,
32373"d - 'Double_t' 10 - MucMomentumY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32374 G__memfunc_setup("SetMucMomentumZ",1533,G__RootEventData_rootcint_460_0_50, 121, -1, -1, 0, 2, 1, 1, 0,
32375"d - 'Double_t' 10 - MucMomentumZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32376 G__memfunc_setup("SetMucVolumeName",1610,G__RootEventData_rootcint_460_0_51, 121, -1, -1, 0, 2, 1, 1, 0,
32377"u 'TString' - 10 - MucVolumeName i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32378 G__memfunc_setup("SetMucVolumeNumber",1842,G__RootEventData_rootcint_460_0_52, 121, -1, -1, 0, 2, 1, 1, 0,
32379"i - 'Int_t' 10 - MucVolumeNumber i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32380 G__memfunc_setup("SetMucPosSigmaAlongZ",1983,G__RootEventData_rootcint_460_0_53, 121, -1, -1, 0, 2, 1, 1, 0,
32381"d - 'Double_t' 10 - MucPosSigmaAlongZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32382 G__memfunc_setup("SetMucPosSigmaAlongT",1977,G__RootEventData_rootcint_460_0_54, 121, -1, -1, 0, 2, 1, 1, 0,
32383"d - 'Double_t' 10 - MucPosSigmaAlongT i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32384 G__memfunc_setup("SetMucPosSigmaAlongX",1981,G__RootEventData_rootcint_460_0_55, 121, -1, -1, 0, 2, 1, 1, 0,
32385"d - 'Double_t' 10 - MucPosSigmaAlongX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32386 G__memfunc_setup("SetMucPosSigmaAlongY",1982,G__RootEventData_rootcint_460_0_56, 121, -1, -1, 0, 2, 1, 1, 0,
32387"d - 'Double_t' 10 - MucPosSigmaAlongY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32388 G__memfunc_setup("SetMucErrorMatrix",1744,G__RootEventData_rootcint_460_0_57, 121, -1, -1, 0, 2, 1, 1, 0,
32389"D - 'Double_t' 12 - MucErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32390 G__memfunc_setup("SetSize",711,G__RootEventData_rootcint_460_0_58, 121, -1, -1, 0, 2, 1, 1, 0,
32391"i - 'Int_t' 0 - size i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32392 G__memfunc_setup("SetExtMucHit",1191,G__RootEventData_rootcint_460_0_59, 121, -1, -1, 0, 14, 1, 1, 0,
32393"d - 'Double_t' 0 - PositionX d - 'Double_t' 0 - PositionY "
32394"d - 'Double_t' 0 - PositionZ d - 'Double_t' 0 - MomentumX "
32395"d - 'Double_t' 0 - MomentumY d - 'Double_t' 0 - MomentumZ "
32396"u 'TString' - 0 - VolumeName i - 'Int_t' 0 - VolumeNumber "
32397"d - 'Double_t' 0 - PosSigmaAlongZ d - 'Double_t' 0 - PosSigmaAlongT "
32398"d - 'Double_t' 0 - PosSigmaAlongX d - 'Double_t' 0 - PosSigmaAlongY "
32399"D - 'Double_t' 2 - ErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32400 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);
32401 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);
32402 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);
32403 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);
32404 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);
32405 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);
32406 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);
32407 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);
32408 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);
32409 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);
32410 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);
32411 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);
32412 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);
32413 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);
32414 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);
32415 G__memfunc_setup("GetTof1ErrorMatrix",1785,G__RootEventData_rootcint_460_0_75, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8,
32416"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
32417"i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32418 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);
32419 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);
32420 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);
32421 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);
32422 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);
32423 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);
32424 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);
32425 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);
32426 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);
32427 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);
32428 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);
32429 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);
32430 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);
32431 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);
32432 G__memfunc_setup("GetTof2ErrorMatrix",1786,G__RootEventData_rootcint_460_0_90, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8,
32433"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
32434"i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32435 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);
32436 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);
32437 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);
32438 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);
32439 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);
32440 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);
32441 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);
32442 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);
32443 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);
32444 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);
32445 G__memfunc_setup("GetEmcErrorMatrix",1716,G__RootEventData_rootcint_460_0_101, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8,
32446"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
32447"i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32448 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);
32449 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);
32450 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);
32451 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);
32452 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);
32453 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);
32454 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);
32455 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);
32456 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);
32457 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);
32458 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);
32459 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);
32460 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);
32461 G__memfunc_setup("GetMucErrorMatrix",1732,G__RootEventData_rootcint_460_0_115, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8,
32462"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
32463"i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32464 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);
32465 G__memfunc_setup("GetPositionX",1229,G__RootEventData_rootcint_460_0_117, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32466"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32467 G__memfunc_setup("GetPositionY",1230,G__RootEventData_rootcint_460_0_118, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32468"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32469 G__memfunc_setup("GetPositionZ",1231,G__RootEventData_rootcint_460_0_119, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32470"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32471 G__memfunc_setup("GetMomentumX",1226,G__RootEventData_rootcint_460_0_120, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32472"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32473 G__memfunc_setup("GetMomentumY",1227,G__RootEventData_rootcint_460_0_121, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32474"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32475 G__memfunc_setup("GetMomentumZ",1228,G__RootEventData_rootcint_460_0_122, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32476"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32477 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,
32478"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32479 G__memfunc_setup("GetVolumeNumber",1537,G__RootEventData_rootcint_460_0_124, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8,
32480"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32481 G__memfunc_setup("GetPosSigmaAlongZ",1678,G__RootEventData_rootcint_460_0_125, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32482"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32483 G__memfunc_setup("GetPosSigmaAlongT",1672,G__RootEventData_rootcint_460_0_126, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32484"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32485 G__memfunc_setup("GetPosSigmaAlongX",1676,G__RootEventData_rootcint_460_0_127, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32486"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32487 G__memfunc_setup("GetPosSigmaAlongY",1677,G__RootEventData_rootcint_460_0_128, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32488"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32489 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,
32490"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32491 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);
32492 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);
32493 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);
32494 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);
32495 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);
32496 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32497 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32498 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);
32499 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);
32500 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);
32501 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);
32502 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);
32503 // automatic copy constructor
32504 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);
32505 // automatic destructor
32506 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);
32507 // automatic assignment operator
32508 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);
32509 G__tag_memfunc_reset();
32510}
32511
32512static void G__setup_memfuncTRecEvTime(void) {
32513 /* TRecEvTime */
32514 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime));
32515 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);
32516 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);
32517 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);
32518 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);
32519 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);
32520 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);
32521 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);
32522 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);
32523 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);
32524 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);
32525 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);
32526 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);
32527 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32528 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32529 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);
32530 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);
32531 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);
32532 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);
32533 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);
32534 // automatic copy constructor
32535 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);
32536 // automatic destructor
32537 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);
32538 // automatic assignment operator
32539 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);
32540 G__tag_memfunc_reset();
32541}
32542
32543static void G__setup_memfuncTRecMdcKalHelixSeg(void) {
32544 /* TRecMdcKalHelixSeg */
32545 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg));
32546 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);
32547 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);
32548 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);
32549 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);
32550 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);
32551 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);
32552 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);
32553 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);
32554 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);
32555 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);
32556 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);
32557 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);
32558 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);
32559 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);
32560 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);
32561 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);
32562 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);
32563 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);
32564 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);
32565 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);
32566 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);
32567 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);
32568 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);
32569 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);
32570 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);
32571 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);
32572 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);
32573 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);
32574 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);
32575 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);
32576 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);
32577 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);
32578 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);
32579 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);
32580 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32581 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32582 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);
32583 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);
32584 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);
32585 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);
32586 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);
32587 // automatic copy constructor
32588 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);
32589 // automatic destructor
32590 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);
32591 // automatic assignment operator
32592 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);
32593 G__tag_memfunc_reset();
32594}
32595
32596static void G__setup_memfuncTRecZddChannel(void) {
32597 /* TRecZddChannel */
32598 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
32599 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);
32600 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);
32601 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);
32602 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);
32603 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);
32604 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);
32605 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);
32606 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);
32607 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);
32608 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);
32609 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);
32610 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);
32611 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);
32612 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);
32613 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);
32614 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);
32615 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32616 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32617 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);
32618 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);
32619 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);
32620 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);
32621 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);
32622 // automatic copy constructor
32623 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);
32624 // automatic destructor
32625 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);
32626 // automatic assignment operator
32627 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);
32628 G__tag_memfunc_reset();
32629}
32630
32631static void G__setup_memfuncTRecTrackEvent(void) {
32632 /* TRecTrackEvent */
32633 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent));
32634 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);
32635 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_477_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32636 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);
32637 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);
32638 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);
32639 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);
32640 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);
32641 G__memfunc_setup("clearRecMdcTrackCol",1864,G__RootEventData_rootcint_477_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32642 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);
32643 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);
32644 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);
32645 G__memfunc_setup("clearRecMdcHitCol",1656,G__RootEventData_rootcint_477_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32646 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);
32647 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);
32648 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);
32649 G__memfunc_setup("clearTofTrackCol",1603,G__RootEventData_rootcint_477_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32650 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);
32651 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);
32652 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);
32653 G__memfunc_setup("clearEmcHitCol",1375,G__RootEventData_rootcint_477_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32654 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);
32655 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);
32656 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);
32657 G__memfunc_setup("clearEmcClusterCol",1820,G__RootEventData_rootcint_477_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32658 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);
32659 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);
32660 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);
32661 G__memfunc_setup("clearEmcShowerCol",1714,G__RootEventData_rootcint_477_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32662 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);
32663 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);
32664 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);
32665 G__memfunc_setup("clearMucTrackCol",1599,G__RootEventData_rootcint_477_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32666 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);
32667 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);
32668 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);
32669 G__memfunc_setup("clearRecMdcDedxCol",1752,G__RootEventData_rootcint_477_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32670 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);
32671 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);
32672 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);
32673 G__memfunc_setup("clearRecMdcDedxHitCol",2045,G__RootEventData_rootcint_477_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32674 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);
32675 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);
32676 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);
32677 G__memfunc_setup("clearExtTrackCol",1611,G__RootEventData_rootcint_477_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32678 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);
32679 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);
32680 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);
32681 G__memfunc_setup("clearRecMdcKalTrackCol",2144,G__RootEventData_rootcint_477_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32682 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);
32683 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);
32684 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);
32685 G__memfunc_setup("clearRecMdcKalHelixSegCol",2436,G__RootEventData_rootcint_477_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32686 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);
32687 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);
32688 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);
32689 G__memfunc_setup("clearEvTimeCol",1391,G__RootEventData_rootcint_477_0_56, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32690 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);
32691 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);
32692 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);
32693 G__memfunc_setup("clearRecZddChannelCol",2074,G__RootEventData_rootcint_477_0_60, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32694 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);
32695 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);
32696 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);
32697 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);
32698 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);
32699 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32700 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32701 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);
32702 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);
32703 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);
32704 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);
32705 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);
32706 // automatic copy constructor
32707 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);
32708 // automatic destructor
32709 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);
32710 // automatic assignment operator
32711 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);
32712 G__tag_memfunc_reset();
32713}
32714
32715static void G__setup_memfuncTMdcTrack(void) {
32716 /* TMdcTrack */
32717 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack));
32718 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);
32719 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);
32720 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);
32721 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);
32722 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);
32723 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);
32724 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);
32725 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);
32726 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);
32727 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);
32728 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);
32729 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);
32730 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);
32731 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);
32732 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);
32733 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);
32734 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);
32735 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);
32736 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);
32737 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);
32738 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);
32739 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);
32740 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);
32741 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);
32742 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);
32743 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);
32744 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);
32745 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);
32746 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);
32747 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);
32748 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);
32749 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);
32750 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);
32751 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);
32752 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);
32753 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);
32754 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);
32755 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);
32756 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32757 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32758 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);
32759 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);
32760 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);
32761 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);
32762 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);
32763 // automatic copy constructor
32764 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);
32765 // automatic destructor
32766 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);
32767 // automatic assignment operator
32768 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);
32769 G__tag_memfunc_reset();
32770}
32771
32772static void G__setup_memfuncTEmcTrack(void) {
32773 /* TEmcTrack */
32774 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack));
32775 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);
32776 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);
32777 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);
32778 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);
32779 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);
32780 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);
32781 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);
32782 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);
32783 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);
32784 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);
32785 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);
32786 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);
32787 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);
32788 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);
32789 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);
32790 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);
32791 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);
32792 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);
32793 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);
32794 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);
32795 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);
32796 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);
32797 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);
32798 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);
32799 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);
32800 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);
32801 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);
32802 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);
32803 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);
32804 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);
32805 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);
32806 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);
32807 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);
32808 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);
32809 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);
32810 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);
32811 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);
32812 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);
32813 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);
32814 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);
32815 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);
32816 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);
32817 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);
32818 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);
32819 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);
32820 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);
32821 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);
32822 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);
32823 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);
32824 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);
32825 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);
32826 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);
32827 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);
32828 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32829 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32830 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);
32831 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);
32832 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);
32833 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);
32834 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);
32835 // automatic copy constructor
32836 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);
32837 // automatic destructor
32838 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);
32839 // automatic assignment operator
32840 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);
32841 G__tag_memfunc_reset();
32842}
32843
32844static void G__setup_memfuncTMucTrack(void) {
32845 /* TMucTrack */
32846 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack));
32847 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);
32848 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);
32849 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);
32850 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);
32851 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);
32852 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);
32853 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);
32854 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);
32855 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);
32856 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);
32857 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);
32858 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);
32859 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);
32860 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);
32861 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);
32862 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);
32863 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);
32864 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);
32865 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);
32866 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);
32867 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);
32868 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);
32869 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);
32870 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);
32871 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);
32872 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);
32873 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);
32874 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);
32875 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);
32876 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);
32877 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);
32878 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);
32879 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);
32880 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);
32881 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);
32882 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);
32883 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);
32884 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);
32885 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);
32886 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);
32887 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);
32888 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);
32889 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);
32890 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);
32891 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);
32892 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);
32893 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);
32894 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);
32895 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);
32896 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);
32897 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);
32898 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);
32899 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);
32900 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);
32901 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);
32902 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);
32903 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);
32904 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);
32905 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);
32906 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);
32907 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);
32908 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);
32909 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);
32910 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);
32911 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);
32912 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);
32913 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);
32914 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);
32915 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32916 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32917 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);
32918 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);
32919 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);
32920 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);
32921 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);
32922 // automatic copy constructor
32923 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);
32924 // automatic destructor
32925 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);
32926 // automatic assignment operator
32927 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);
32928 G__tag_memfunc_reset();
32929}
32930
32931static void G__setup_memfuncTMdcDedx(void) {
32932 /* TMdcDedx */
32933 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx));
32934 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);
32935 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);
32936 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);
32937 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);
32938 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);
32939 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);
32940 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);
32941 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);
32942 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);
32943 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);
32944 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);
32945 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);
32946 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);
32947 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);
32948 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);
32949 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);
32950 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);
32951 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);
32952 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);
32953 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);
32954 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);
32955 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);
32956 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);
32957 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);
32958 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);
32959 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);
32960 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);
32961 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);
32962 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);
32963 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);
32964 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);
32965 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);
32966 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);
32967 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);
32968 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);
32969 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);
32970 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);
32971 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32972 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32973 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);
32974 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);
32975 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);
32976 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);
32977 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);
32978 // automatic copy constructor
32979 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);
32980 // automatic destructor
32981 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);
32982 // automatic assignment operator
32983 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);
32984 G__tag_memfunc_reset();
32985}
32986
32987static void G__setup_memfuncTExtTrack(void) {
32988 /* TExtTrack */
32989 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack));
32990 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);
32991 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);
32992 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);
32993 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);
32994 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);
32995 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);
32996 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);
32997 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);
32998 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);
32999 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);
33000 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);
33001 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);
33002 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);
33003 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);
33004 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);
33005 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);
33006 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);
33007 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);
33008 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);
33009 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);
33010 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);
33011 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);
33012 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);
33013 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);
33014 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);
33015 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);
33016 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);
33017 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);
33018 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);
33019 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);
33020 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);
33021 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);
33022 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);
33023 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);
33024 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);
33025 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);
33026 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);
33027 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);
33028 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);
33029 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);
33030 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);
33031 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);
33032 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);
33033 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);
33034 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);
33035 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);
33036 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);
33037 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);
33038 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);
33039 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);
33040 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);
33041 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);
33042 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);
33043 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);
33044 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);
33045 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);
33046 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);
33047 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);
33048 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);
33049 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);
33050 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);
33051 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);
33052 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);
33053 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);
33054 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);
33055 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);
33056 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);
33057 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);
33058 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);
33059 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);
33060 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);
33061 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);
33062 G__memfunc_setup("GetTof1ErrorMatrix",1785,G__RootEventData_rootcint_483_0_73, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33063"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33064 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);
33065 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);
33066 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);
33067 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);
33068 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);
33069 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);
33070 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);
33071 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);
33072 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);
33073 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);
33074 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);
33075 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);
33076 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);
33077 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);
33078 G__memfunc_setup("GetTof2ErrorMatrix",1786,G__RootEventData_rootcint_483_0_88, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33079"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33080 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);
33081 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);
33082 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);
33083 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);
33084 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);
33085 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);
33086 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);
33087 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);
33088 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);
33089 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);
33090 G__memfunc_setup("GetEmcErrorMatrix",1716,G__RootEventData_rootcint_483_0_99, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33091"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33092 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);
33093 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);
33094 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);
33095 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);
33096 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);
33097 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);
33098 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);
33099 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);
33100 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);
33101 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);
33102 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);
33103 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);
33104 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);
33105 G__memfunc_setup("GetMucErrorMatrix",1732,G__RootEventData_rootcint_483_0_113, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33106"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33107 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);
33108 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);
33109 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);
33110 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);
33111 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);
33112 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33113 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33114 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);
33115 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);
33116 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);
33117 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);
33118 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);
33119 // automatic copy constructor
33120 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);
33121 // automatic destructor
33122 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);
33123 // automatic assignment operator
33124 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);
33125 G__tag_memfunc_reset();
33126}
33127
33128static void G__setup_memfuncTMdcKalTrack(void) {
33129 /* TMdcKalTrack */
33130 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack));
33131 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);
33132 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);
33133 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);
33134 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);
33135 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);
33136 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);
33137 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);
33138 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);
33139 G__memfunc_setup("getZError",932,G__RootEventData_rootcint_484_0_9, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33140"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33141 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);
33142 G__memfunc_setup("getZErrorE",1001,G__RootEventData_rootcint_484_0_11, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33143"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33144 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);
33145 G__memfunc_setup("getZErrorMu",1126,G__RootEventData_rootcint_484_0_13, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33146"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33147 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);
33148 G__memfunc_setup("getZErrorK",1007,G__RootEventData_rootcint_484_0_15, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33149"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33150 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);
33151 G__memfunc_setup("getZErrorP",1012,G__RootEventData_rootcint_484_0_17, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33152"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33153 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);
33154 G__memfunc_setup("getFError",912,G__RootEventData_rootcint_484_0_19, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33155"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33156 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);
33157 G__memfunc_setup("getFErrorE",981,G__RootEventData_rootcint_484_0_21, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33158"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33159 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);
33160 G__memfunc_setup("getFErrorMu",1106,G__RootEventData_rootcint_484_0_23, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33161"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33162 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);
33163 G__memfunc_setup("getFErrorK",987,G__RootEventData_rootcint_484_0_25, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33164"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33165 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);
33166 G__memfunc_setup("getFErrorP",992,G__RootEventData_rootcint_484_0_27, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33167"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33168 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);
33169 G__memfunc_setup("setStat",744,G__RootEventData_rootcint_484_0_29, 121, -1, -1, 0, 2, 1, 1, 0,
33170"i - 'Int_t' 10 - stat i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33171 G__memfunc_setup("setStat2",794,G__RootEventData_rootcint_484_0_30, 121, -1, -1, 0, 2, 1, 1, 0,
33172"i - 'Int_t' 10 - stat i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33173 G__memfunc_setup("setChisq",836,G__RootEventData_rootcint_484_0_31, 121, -1, -1, 0, 2, 1, 1, 0,
33174"d - 'Double_t' 10 - chisq i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33175 G__memfunc_setup("setNdf",612,G__RootEventData_rootcint_484_0_32, 121, -1, -1, 0, 2, 1, 1, 0,
33176"i - 'Int_t' 10 - ndf i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33177 G__memfunc_setup("setNlayer",951,G__RootEventData_rootcint_484_0_33, 121, -1, -1, 0, 2, 1, 1, 0,
33178"i - 'Int_t' 10 - nlayer i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33179 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);
33180 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);
33181 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);
33182 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);
33183 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);
33184 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);
33185 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);
33186 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);
33187 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);
33188 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);
33189 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);
33190 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);
33191 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);
33192 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);
33193 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);
33194 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);
33195 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);
33196 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);
33197 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);
33198 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);
33199 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);
33200 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);
33201 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);
33202 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);
33203 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);
33204 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33205 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33206 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);
33207 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);
33208 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);
33209 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);
33210 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);
33211 // automatic copy constructor
33212 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);
33213 // automatic destructor
33214 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);
33215 // automatic assignment operator
33216 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);
33217 G__tag_memfunc_reset();
33218}
33219
33220static void G__setup_memfuncTDstEvent(void) {
33221 /* TDstEvent */
33222 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent));
33223 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);
33224 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_485_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33225 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);
33226 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);
33227 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);
33228 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);
33229 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);
33230 G__memfunc_setup("clearMdcTrackCol",1582,G__RootEventData_rootcint_485_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33231 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);
33232 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);
33233 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);
33234 G__memfunc_setup("clearEmcTrackCol",1583,G__RootEventData_rootcint_485_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33235 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);
33236 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);
33237 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);
33238 G__memfunc_setup("clearTofTrackCol",1603,G__RootEventData_rootcint_485_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33239 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);
33240 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);
33241 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);
33242 G__memfunc_setup("clearMucTrackCol",1599,G__RootEventData_rootcint_485_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33243 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);
33244 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);
33245 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);
33246 G__memfunc_setup("clearMdcDedxCol",1470,G__RootEventData_rootcint_485_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33247 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);
33248 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);
33249 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);
33250 G__memfunc_setup("clearExtTrackCol",1611,G__RootEventData_rootcint_485_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33251 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);
33252 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);
33253 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);
33254 G__memfunc_setup("clearMdcKalTrackCol",1862,G__RootEventData_rootcint_485_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33255 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);
33256 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);
33257 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);
33258 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);
33259 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);
33260 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33261 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33262 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);
33263 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);
33264 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);
33265 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);
33266 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);
33267 // automatic copy constructor
33268 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);
33269 // automatic destructor
33270 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);
33271 // automatic assignment operator
33272 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);
33273 G__tag_memfunc_reset();
33274}
33275
33276static void G__setup_memfuncTMdcMc(void) {
33277 /* TMdcMc */
33278 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc));
33279 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);
33280 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);
33281 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);
33282 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);
33283 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);
33284 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);
33285 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);
33286 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);
33287 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);
33288 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);
33289 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);
33290 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);
33291 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);
33292 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);
33293 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);
33294 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);
33295 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);
33296 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);
33297 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);
33298 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);
33299 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);
33300 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);
33301 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33302 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33303 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);
33304 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);
33305 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);
33306 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);
33307 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);
33308 // automatic copy constructor
33309 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);
33310 // automatic destructor
33311 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);
33312 // automatic assignment operator
33313 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);
33314 G__tag_memfunc_reset();
33315}
33316
33317static void G__setup_memfuncTEmcMc(void) {
33318 /* TEmcMc */
33319 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc));
33320 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);
33321 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);
33322 G__memfunc_setup("getHitEmc",890,G__RootEventData_rootcint_487_0_3, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33323 G__memfunc_setup("getPDGCode",918,G__RootEventData_rootcint_487_0_4, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33324 G__memfunc_setup("getPDGCharge",1125,G__RootEventData_rootcint_487_0_5, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33325 G__memfunc_setup("getTime",719,G__RootEventData_rootcint_487_0_6, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33326 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);
33327 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);
33328 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);
33329 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);
33330 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);
33331 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);
33332 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);
33333 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);
33334 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);
33335 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);
33336 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);
33337 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);
33338 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);
33339 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);
33340 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);
33341 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);
33342 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);
33343 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);
33344 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);
33345 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);
33346 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);
33347 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);
33348 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);
33349 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);
33350 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);
33351 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);
33352 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);
33353 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);
33354 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33355 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33356 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);
33357 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);
33358 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);
33359 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);
33360 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);
33361 // automatic copy constructor
33362 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);
33363 // automatic destructor
33364 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);
33365 // automatic assignment operator
33366 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);
33367 G__tag_memfunc_reset();
33368}
33369
33370static void G__setup_memfuncTTofMc(void) {
33371 /* TTofMc */
33372 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc));
33373 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);
33374 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);
33375 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);
33376 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);
33377 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);
33378 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);
33379 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);
33380 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);
33381 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);
33382 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);
33383 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);
33384 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);
33385 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);
33386 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);
33387 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);
33388 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);
33389 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);
33390 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);
33391 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);
33392 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);
33393 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);
33394 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);
33395 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);
33396 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);
33397 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);
33398 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);
33399 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33400 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33401 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);
33402 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);
33403 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);
33404 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);
33405 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);
33406 // automatic copy constructor
33407 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);
33408 // automatic destructor
33409 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);
33410 // automatic assignment operator
33411 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);
33412 G__tag_memfunc_reset();
33413}
33414
33415static void G__setup_memfuncTMucMc(void) {
33416 /* TMucMc */
33417 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc));
33418 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);
33419 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);
33420 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);
33421 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);
33422 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);
33423 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);
33424 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);
33425 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);
33426 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);
33427 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);
33428 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);
33429 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);
33430 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);
33431 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);
33432 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);
33433 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);
33434 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);
33435 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);
33436 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);
33437 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);
33438 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);
33439 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);
33440 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33441 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33442 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);
33443 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);
33444 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);
33445 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);
33446 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);
33447 // automatic copy constructor
33448 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);
33449 // automatic destructor
33450 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);
33451 // automatic assignment operator
33452 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);
33453 G__tag_memfunc_reset();
33454}
33455
33456static void G__setup_memfuncTMcParticle(void) {
33457 /* TMcParticle */
33458 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle));
33459 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);
33460 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);
33461 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);
33462 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);
33463 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);
33464 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);
33465 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);
33466 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);
33467 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);
33468 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);
33469 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);
33470 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);
33471 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);
33472 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);
33473 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);
33474 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);
33475 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);
33476 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);
33477 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);
33478 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);
33479 G__memfunc_setup("primaryParticle",1592,G__RootEventData_rootcint_490_0_21, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33480 G__memfunc_setup("leafParticle",1228,G__RootEventData_rootcint_490_0_22, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33481 G__memfunc_setup("decayFromGenerator",1857,G__RootEventData_rootcint_490_0_23, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33482 G__memfunc_setup("decayInFlight",1307,G__RootEventData_rootcint_490_0_24, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33483 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);
33484 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);
33485 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);
33486 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);
33487 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);
33488 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);
33489 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);
33490 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);
33491 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);
33492 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);
33493 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);
33494 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);
33495 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);
33496 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);
33497 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);
33498 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);
33499 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);
33500 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);
33501 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);
33502 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);
33503 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);
33504 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);
33505 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);
33506 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);
33507 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33508 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33509 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);
33510 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);
33511 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);
33512 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);
33513 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);
33514 // automatic copy constructor
33515 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);
33516 // automatic destructor
33517 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);
33518 // automatic assignment operator
33519 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);
33520 G__tag_memfunc_reset();
33521}
33522
33523static void G__setup_memfuncTMcEvent(void) {
33524 /* TMcEvent */
33525 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent));
33526 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);
33527 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_492_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33528 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);
33529 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);
33530 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);
33531 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);
33532 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);
33533 G__memfunc_setup("clearMdcMcHitCol",1550,G__RootEventData_rootcint_492_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33534 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);
33535 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);
33536 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);
33537 G__memfunc_setup("clearEmcMcHitCol",1551,G__RootEventData_rootcint_492_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33538 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);
33539 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);
33540 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);
33541 G__memfunc_setup("clearTofMcHitCol",1571,G__RootEventData_rootcint_492_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33542 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);
33543 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);
33544 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);
33545 G__memfunc_setup("clearMucMcHitCol",1567,G__RootEventData_rootcint_492_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33546 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);
33547 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);
33548 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);
33549 G__memfunc_setup("clearMcParticleCol",1801,G__RootEventData_rootcint_492_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33550 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);
33551 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);
33552 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);
33553 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);
33554 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);
33555 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33556 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33557 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);
33558 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);
33559 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);
33560 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);
33561 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);
33562 // automatic copy constructor
33563 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);
33564 // automatic destructor
33565 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);
33566 // automatic assignment operator
33567 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);
33568 G__tag_memfunc_reset();
33569}
33570
33571static void G__setup_memfuncTEvtHeader(void) {
33572 /* TEvtHeader */
33573 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader));
33574 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);
33575 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_493_0_2, 121, -1, -1, 0, 3, 1, 1, 0,
33576"i - 'Int_t' 0 - Id i - 'Int_t' 0 - runId "
33577"h - 'UInt_t' 0 - evenTag", (char*)NULL, (void*) NULL, 0);
33578 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);
33579 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);
33580 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);
33581 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);
33582 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);
33583 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);
33584 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);
33585 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);
33586 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);
33587 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);
33588 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);
33589 G__memfunc_setup("setEtsT1",765,G__RootEventData_rootcint_493_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "k - - 0 - value", (char*)NULL, (void*) NULL, 0);
33590 G__memfunc_setup("setEtsT2",766,G__RootEventData_rootcint_493_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "k - - 0 - value", (char*)NULL, (void*) NULL, 0);
33591 G__memfunc_setup("getEtsT1",753,G__RootEventData_rootcint_493_0_16, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33592 G__memfunc_setup("getEtsT2",754,G__RootEventData_rootcint_493_0_17, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33593 G__memfunc_setup("Class",502,G__RootEventData_rootcint_493_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtHeader::Class) ), 0);
33594 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_493_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtHeader::Class_Name) ), 0);
33595 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_493_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtHeader::Class_Version) ), 0);
33596 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_493_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtHeader::Dictionary) ), 0);
33597 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);
33598 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33599 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33600 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_493_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33601 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_493_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtHeader::DeclFileName) ), 0);
33602 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_493_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtHeader::ImplFileLine) ), 0);
33603 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_493_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtHeader::ImplFileName) ), 0);
33604 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_493_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtHeader::DeclFileLine) ), 0);
33605 // automatic copy constructor
33606 G__memfunc_setup("TEvtHeader", 972, G__RootEventData_rootcint_493_0_30, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader), -1, 0, 1, 1, 1, 0, "u 'TEvtHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
33607 // automatic destructor
33608 G__memfunc_setup("~TEvtHeader", 1098, G__RootEventData_rootcint_493_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33609 // automatic assignment operator
33610 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_493_0_32, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader), -1, 1, 1, 1, 1, 0, "u 'TEvtHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
33611 G__tag_memfunc_reset();
33612}
33613
33614static void G__setup_memfuncTEvtNavigator(void) {
33615 /* TEvtNavigator */
33616 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator));
33617 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);
33618 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);
33619 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);
33620 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);
33621 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);
33622 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);
33623 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);
33624 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);
33625 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);
33626 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);
33627 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);
33628 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);
33629 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33630 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33631 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);
33632 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);
33633 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);
33634 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);
33635 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);
33636 // automatic copy constructor
33637 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);
33638 // automatic destructor
33639 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);
33640 // automatic assignment operator
33641 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);
33642 G__tag_memfunc_reset();
33643}
33644
33645static void G__setup_memfuncTTrigData(void) {
33646 /* TTrigData */
33647 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData));
33648 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);
33649 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);
33650 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);
33651 G__memfunc_setup("setTrigCondition",1673,G__RootEventData_rootcint_507_0_4, 121, -1, -1, 0, 2, 1, 1, 0,
33652"i - - 0 - i i - - 0 - j", (char*)NULL, (void*) NULL, 0);
33653 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);
33654 G__memfunc_setup("setTrigChannel",1435,G__RootEventData_rootcint_507_0_6, 121, -1, -1, 0, 2, 1, 1, 0,
33655"i - - 0 - i i - - 0 - j", (char*)NULL, (void*) NULL, 0);
33656 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);
33657 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);
33658 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);
33659 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);
33660 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);
33661 G__memfunc_setup("getTrigCondition",1661,G__RootEventData_rootcint_507_0_12, 73, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33662 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);
33663 G__memfunc_setup("getTrigChannel",1423,G__RootEventData_rootcint_507_0_14, 73, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33664 G__memfunc_setup("getTimeWindow",1351,G__RootEventData_rootcint_507_0_15, 105, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33665 G__memfunc_setup("getTimingType",1354,G__RootEventData_rootcint_507_0_16, 105, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33666 G__memfunc_setup("getPreScale",1103,G__RootEventData_rootcint_507_0_17, 103, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33667 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);
33668 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);
33669 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);
33670 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);
33671 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);
33672 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33673 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33674 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);
33675 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);
33676 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);
33677 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);
33678 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);
33679 // automatic copy constructor
33680 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);
33681 // automatic destructor
33682 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);
33683 // automatic assignment operator
33684 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);
33685 G__tag_memfunc_reset();
33686}
33687
33688static void G__setup_memfuncTTrigEvent(void) {
33689 /* TTrigEvent */
33690 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent));
33691 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);
33692 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_508_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33693 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);
33694 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);
33695 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);
33696 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);
33697 G__memfunc_setup("clearTrigData",1303,G__RootEventData_rootcint_508_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33698 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);
33699 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);
33700 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);
33701 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);
33702 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);
33703 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33704 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33705 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);
33706 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);
33707 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);
33708 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);
33709 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);
33710 // automatic copy constructor
33711 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);
33712 // automatic destructor
33713 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);
33714 // automatic assignment operator
33715 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);
33716 G__tag_memfunc_reset();
33717}
33718
33719static void G__setup_memfuncTHltRaw(void) {
33720 /* THltRaw */
33721 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw));
33722 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);
33723 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);
33724 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);
33725 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);
33726 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);
33727 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);
33728 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33729 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33730 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);
33731 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);
33732 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);
33733 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);
33734 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);
33735 // automatic copy constructor
33736 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);
33737 // automatic destructor
33738 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);
33739 // automatic assignment operator
33740 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);
33741 G__tag_memfunc_reset();
33742}
33743
33744static void G__setup_memfuncTHltInf(void) {
33745 /* THltInf */
33746 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf));
33747 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);
33748 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);
33749 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);
33750 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);
33751 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);
33752 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);
33753 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);
33754 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);
33755 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);
33756 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);
33757 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);
33758 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);
33759 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);
33760 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);
33761 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);
33762 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);
33763 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);
33764 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);
33765 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);
33766 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);
33767 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);
33768 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);
33769 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);
33770 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);
33771 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);
33772 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);
33773 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);
33774 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);
33775 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);
33776 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);
33777 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33778 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33779 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);
33780 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);
33781 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);
33782 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);
33783 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);
33784 // automatic copy constructor
33785 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);
33786 // automatic destructor
33787 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);
33788 // automatic assignment operator
33789 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);
33790 G__tag_memfunc_reset();
33791}
33792
33793static void G__setup_memfuncTDstHltInf(void) {
33794 /* TDstHltInf */
33795 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf));
33796 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);
33797 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);
33798 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);
33799 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);
33800 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);
33801 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);
33802 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);
33803 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);
33804 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);
33805 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);
33806 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);
33807 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);
33808 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);
33809 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);
33810 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);
33811 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);
33812 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);
33813 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);
33814 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);
33815 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);
33816 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33817 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33818 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);
33819 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);
33820 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);
33821 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);
33822 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);
33823 // automatic copy constructor
33824 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);
33825 // automatic destructor
33826 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);
33827 // automatic assignment operator
33828 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);
33829 G__tag_memfunc_reset();
33830}
33831
33832static void G__setup_memfuncTHltEvent(void) {
33833 /* THltEvent */
33834 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent));
33835 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);
33836 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_512_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33837 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);
33838 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);
33839 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);
33840 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);
33841 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);
33842 G__memfunc_setup("clearHltRawCol",1399,G__RootEventData_rootcint_512_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33843 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);
33844 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);
33845 G__memfunc_setup("clearHltInf",1100,G__RootEventData_rootcint_512_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33846 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);
33847 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);
33848 G__memfunc_setup("clearDstHltInf",1399,G__RootEventData_rootcint_512_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33849 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);
33850 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);
33851 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);
33852 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);
33853 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);
33854 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33855 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33856 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);
33857 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);
33858 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);
33859 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);
33860 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);
33861 // automatic copy constructor
33862 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);
33863 // automatic destructor
33864 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);
33865 // automatic assignment operator
33866 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);
33867 G__tag_memfunc_reset();
33868}
33869
33870static void G__setup_memfuncTDisTrack(void) {
33871 /* TDisTrack */
33872 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack));
33873 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);
33874 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_513_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33875 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);
33876 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);
33877 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);
33878 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);
33879 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);
33880 G__memfunc_setup("clearRecMdcTrackCol",1864,G__RootEventData_rootcint_513_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33881 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);
33882 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);
33883 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);
33884 G__memfunc_setup("clearRecMdcHitCol",1656,G__RootEventData_rootcint_513_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33885 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);
33886 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);
33887 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);
33888 G__memfunc_setup("clearTofTrackCol",1603,G__RootEventData_rootcint_513_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33889 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);
33890 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);
33891 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);
33892 G__memfunc_setup("clearMucTrackCol",1599,G__RootEventData_rootcint_513_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33893 G__memfunc_setup("getMdcTrackNum",1401,G__RootEventData_rootcint_513_0_21, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33894 G__memfunc_setup("getTofTrackNum",1422,G__RootEventData_rootcint_513_0_22, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33895 G__memfunc_setup("getEmcShowerNum",1533,G__RootEventData_rootcint_513_0_23, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33896 G__memfunc_setup("getMucTrackNum",1418,G__RootEventData_rootcint_513_0_24, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33897 G__memfunc_setup("getMdcHitNum",1193,G__RootEventData_rootcint_513_0_25, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33898 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);
33899 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);
33900 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);
33901 G__memfunc_setup("clearEmcShowerCol",1714,G__RootEventData_rootcint_513_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33902 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);
33903 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);
33904 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);
33905 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);
33906 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);
33907 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33908 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33909 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);
33910 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);
33911 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);
33912 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);
33913 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);
33914 // automatic copy constructor
33915 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);
33916 // automatic destructor
33917 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);
33918 // automatic assignment operator
33919 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);
33920 G__tag_memfunc_reset();
33921}
33922
33923static void G__setup_memfuncTEvtRecEvent(void) {
33924 /* TEvtRecEvent */
33925 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent));
33926 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);
33927 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_514_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33928 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);
33929 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);
33930 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);
33931 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);
33932 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);
33933 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);
33934 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);
33935 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);
33936 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);
33937 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);
33938 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);
33939 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);
33940 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);
33941 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);
33942 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);
33943 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);
33944 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);
33945 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);
33946 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);
33947 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);
33948 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);
33949 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33950 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33951 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);
33952 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);
33953 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);
33954 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);
33955 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);
33956 // automatic copy constructor
33957 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);
33958 // automatic destructor
33959 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);
33960 // automatic assignment operator
33961 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);
33962 G__tag_memfunc_reset();
33963}
33964
33965static void G__setup_memfuncTEvtRecTrack(void) {
33966 /* TEvtRecTrack */
33967 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack));
33968 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);
33969 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);
33970 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);
33971 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);
33972 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);
33973 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);
33974 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);
33975 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);
33976 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);
33977 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);
33978 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);
33979 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);
33980 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);
33981 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);
33982 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);
33983 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);
33984 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);
33985 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);
33986 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);
33987 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);
33988 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);
33989 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);
33990 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);
33991 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);
33992 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);
33993 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);
33994 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);
33995 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33996 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33997 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);
33998 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);
33999 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);
34000 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);
34001 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);
34002 // automatic copy constructor
34003 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);
34004 // automatic destructor
34005 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);
34006 // automatic assignment operator
34007 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);
34008 G__tag_memfunc_reset();
34009}
34010
34011static void G__setup_memfuncTEvtRecPrimaryVertex(void) {
34012 /* TEvtRecPrimaryVertex */
34013 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex));
34014 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);
34015 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);
34016 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);
34017 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);
34018 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);
34019 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);
34020 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);
34021 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);
34022 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);
34023 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);
34024 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);
34025 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);
34026 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);
34027 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);
34028 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);
34029 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);
34030 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);
34031 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);
34032 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);
34033 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);
34034 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);
34035 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);
34036 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34037 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34038 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);
34039 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);
34040 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);
34041 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);
34042 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);
34043 // automatic copy constructor
34044 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);
34045 // automatic destructor
34046 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);
34047 // automatic assignment operator
34048 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);
34049 G__tag_memfunc_reset();
34050}
34051
34052static void G__setup_memfuncTEvtRecVeeVertex(void) {
34053 /* TEvtRecVeeVertex */
34054 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex));
34055 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);
34056 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);
34057 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);
34058 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);
34059 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);
34060 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);
34061 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);
34062 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);
34063 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);
34064 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);
34065 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);
34066 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);
34067 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);
34068 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);
34069 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);
34070 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);
34071 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);
34072 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);
34073 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);
34074 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);
34075 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);
34076 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);
34077 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);
34078 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);
34079 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);
34080 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);
34081 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);
34082 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);
34083 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34084 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34085 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);
34086 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);
34087 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);
34088 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);
34089 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);
34090 // automatic copy constructor
34091 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);
34092 // automatic destructor
34093 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);
34094 // automatic assignment operator
34095 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);
34096 G__tag_memfunc_reset();
34097}
34098
34099static void G__setup_memfuncTEvtRecPi0(void) {
34100 /* TEvtRecPi0 */
34101 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0));
34102 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);
34103 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);
34104 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);
34105 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);
34106 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);
34107 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);
34108 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);
34109 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);
34110 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);
34111 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);
34112 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);
34113 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);
34114 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);
34115 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);
34116 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);
34117 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);
34118 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);
34119 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);
34120 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);
34121 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);
34122 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);
34123 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);
34124 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);
34125 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);
34126 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);
34127 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);
34128 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);
34129 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);
34130 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);
34131 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);
34132 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34133 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34134 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);
34135 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);
34136 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);
34137 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);
34138 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);
34139 // automatic copy constructor
34140 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);
34141 // automatic destructor
34142 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);
34143 // automatic assignment operator
34144 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);
34145 G__tag_memfunc_reset();
34146}
34147
34148static void G__setup_memfuncTEvtRecEtaToGG(void) {
34149 /* TEvtRecEtaToGG */
34150 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG));
34151 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);
34152 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);
34153 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);
34154 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);
34155 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);
34156 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);
34157 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);
34158 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);
34159 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);
34160 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);
34161 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);
34162 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);
34163 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);
34164 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);
34165 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);
34166 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);
34167 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);
34168 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);
34169 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);
34170 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);
34171 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);
34172 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);
34173 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);
34174 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);
34175 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);
34176 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);
34177 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);
34178 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);
34179 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);
34180 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);
34181 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34182 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34183 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);
34184 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);
34185 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);
34186 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);
34187 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);
34188 // automatic copy constructor
34189 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);
34190 // automatic destructor
34191 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);
34192 // automatic assignment operator
34193 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);
34194 G__tag_memfunc_reset();
34195}
34196
34197static void G__setup_memfuncTEvtRecDTag(void) {
34198 /* TEvtRecDTag */
34199 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag));
34200 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);
34201 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);
34202 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);
34203 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);
34204 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);
34205 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);
34206 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);
34207 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);
34208 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);
34209 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);
34210 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);
34211 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);
34212 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);
34213 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);
34214 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);
34215 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);
34216 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);
34217 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);
34218 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);
34219 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);
34220 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);
34221 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);
34222 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);
34223 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);
34224 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);
34225 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);
34226 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);
34227 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);
34228 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);
34229 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);
34230 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);
34231 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);
34232 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);
34233 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);
34234 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);
34235 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);
34236 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);
34237 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);
34238 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);
34239 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);
34240 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);
34241 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);
34242 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);
34243 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);
34244 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);
34245 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);
34246 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);
34247 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);
34248 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);
34249 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);
34250 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34251 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34252 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);
34253 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);
34254 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);
34255 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);
34256 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);
34257 // automatic copy constructor
34258 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);
34259 // automatic destructor
34260 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);
34261 // automatic assignment operator
34262 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);
34263 G__tag_memfunc_reset();
34264}
34265
34266static void G__setup_memfuncTEvtRecObject(void) {
34267 /* TEvtRecObject */
34268 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject));
34269 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);
34270 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_521_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34271 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);
34272 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);
34273 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);
34274 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);
34275 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);
34276 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);
34277 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);
34278 G__memfunc_setup("clearEvtRecTrackCol",1891,G__RootEventData_rootcint_521_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34279 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);
34280 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);
34281 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);
34282 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);
34283 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);
34284 G__memfunc_setup("clearEvtRecVeeVertexCol",2316,G__RootEventData_rootcint_521_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34285 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);
34286 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);
34287 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);
34288 G__memfunc_setup("clearEvtRecPi0Col",1623,G__RootEventData_rootcint_521_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34289 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);
34290 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);
34291 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);
34292 G__memfunc_setup("clearEvtRecEtaToGGCol",2009,G__RootEventData_rootcint_521_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34293 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);
34294 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);
34295 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);
34296 G__memfunc_setup("clearEvtRecDTagCol",1742,G__RootEventData_rootcint_521_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34297 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);
34298 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);
34299 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);
34300 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);
34301 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);
34302 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34303 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34304 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);
34305 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);
34306 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);
34307 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);
34308 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);
34309 // automatic copy constructor
34310 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);
34311 // automatic destructor
34312 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);
34313 // automatic assignment operator
34314 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);
34315 G__tag_memfunc_reset();
34316}
34317
34318static void G__setup_memfuncTMcHitTof(void) {
34319 /* TMcHitTof */
34320 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof));
34321 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);
34322 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);
34323 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);
34324 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);
34325 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);
34326 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);
34327 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);
34328 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);
34329 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);
34330 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);
34331 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);
34332 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);
34333 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);
34334 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);
34335 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);
34336 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);
34337 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);
34338 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);
34339 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);
34340 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);
34341 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);
34342 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);
34343 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);
34344 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);
34345 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);
34346 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);
34347 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);
34348 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);
34349 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);
34350 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);
34351 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);
34352 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);
34353 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34354 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34355 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);
34356 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);
34357 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);
34358 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);
34359 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);
34360 // automatic copy constructor
34361 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);
34362 // automatic destructor
34363 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);
34364 // automatic assignment operator
34365 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);
34366 G__tag_memfunc_reset();
34367}
34368
34369static void G__setup_memfuncTMcHitMdc(void) {
34370 /* TMcHitMdc */
34371 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc));
34372 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);
34373 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);
34374 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);
34375 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);
34376 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);
34377 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);
34378 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);
34379 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);
34380 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);
34381 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);
34382 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);
34383 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);
34384 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);
34385 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);
34386 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);
34387 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);
34388 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);
34389 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);
34390 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);
34391 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);
34392 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);
34393 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);
34394 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);
34395 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);
34396 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);
34397 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);
34398 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);
34399 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);
34400 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34401 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34402 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);
34403 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);
34404 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);
34405 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);
34406 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);
34407 // automatic copy constructor
34408 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);
34409 // automatic destructor
34410 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);
34411 // automatic assignment operator
34412 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);
34413 G__tag_memfunc_reset();
34414}
34415
34416static void G__setup_memfuncTMcDigiEmc(void) {
34417 /* TMcDigiEmc */
34418 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc));
34419 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);
34420 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);
34421 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);
34422 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);
34423 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);
34424 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);
34425 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);
34426 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);
34427 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);
34428 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);
34429 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);
34430 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);
34431 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);
34432 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);
34433 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);
34434 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);
34435 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);
34436 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);
34437 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34438 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34439 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);
34440 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);
34441 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);
34442 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);
34443 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);
34444 // automatic copy constructor
34445 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);
34446 // automatic destructor
34447 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);
34448 // automatic assignment operator
34449 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);
34450 G__tag_memfunc_reset();
34451}
34452
34453static void G__setup_memfuncTMcHitEvent(void) {
34454 /* TMcHitEvent */
34455 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent));
34456 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);
34457 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);
34458 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);
34459 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);
34460 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);
34461 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);
34462 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);
34463 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);
34464 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);
34465 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);
34466 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);
34467 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);
34468 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);
34469 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);
34470 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);
34471 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);
34472 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);
34473 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);
34474 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);
34475 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34476 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34477 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);
34478 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);
34479 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);
34480 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);
34481 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);
34482 // automatic copy constructor
34483 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);
34484 // automatic destructor
34485 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);
34486 // automatic assignment operator
34487 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);
34488 G__tag_memfunc_reset();
34489}
34490
34491static void G__setup_memfuncTBossFullEvent(void) {
34492 /* TBossFullEvent */
34493 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent));
34494 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);
34495 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);
34496 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);
34497 G__memfunc_setup("reset",547,G__RootEventData_rootcint_563_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34498 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);
34499 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);
34500 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);
34501 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);
34502 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);
34503 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);
34504 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);
34505 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);
34506 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);
34507 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);
34508 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);
34509 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);
34510 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);
34511 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);
34512 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);
34513 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);
34514 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);
34515 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);
34516 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);
34517 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);
34518 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);
34519 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34520 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34521 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);
34522 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);
34523 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);
34524 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);
34525 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);
34526 // automatic copy constructor
34527 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);
34528 // automatic destructor
34529 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);
34530 // automatic assignment operator
34531 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);
34532 G__tag_memfunc_reset();
34533}
34534
34535
34536/*********************************************************
34537* Member function information setup
34538*********************************************************/
34539extern "C" void G__cpp_setup_memfuncRootEventData_rootcint() {
34540}
34541
34542/*********************************************************
34543* Global variable information setup for each class
34544*********************************************************/
34545static void G__cpp_setup_global0() {
34546
34547 /* Setting up global variables */
34548 G__resetplocal();
34549
34550}
34551
34552static void G__cpp_setup_global1() {
34553}
34554
34555static void G__cpp_setup_global2() {
34556
34557 G__resetglobalenv();
34558}
34559extern "C" void G__cpp_setup_globalRootEventData_rootcint() {
34560 G__cpp_setup_global0();
34561 G__cpp_setup_global1();
34562 G__cpp_setup_global2();
34563}
34564
34565/*********************************************************
34566* Global function information setup for each class
34567*********************************************************/
34568static void G__cpp_setup_func0() {
34569 G__lastifuncposition();
34570
34571}
34572
34573static void G__cpp_setup_func1() {
34574}
34575
34576static void G__cpp_setup_func2() {
34577}
34578
34579static void G__cpp_setup_func3() {
34580}
34581
34582static void G__cpp_setup_func4() {
34583}
34584
34585static void G__cpp_setup_func5() {
34586}
34587
34588static void G__cpp_setup_func6() {
34589}
34590
34591static void G__cpp_setup_func7() {
34592}
34593
34594static void G__cpp_setup_func8() {
34595}
34596
34597static void G__cpp_setup_func9() {
34598}
34599
34600static void G__cpp_setup_func10() {
34601}
34602
34603static void G__cpp_setup_func11() {
34604}
34605
34606static void G__cpp_setup_func12() {
34607}
34608
34609static void G__cpp_setup_func13() {
34610}
34611
34612static void G__cpp_setup_func14() {
34613}
34614
34615static void G__cpp_setup_func15() {
34616}
34617
34618static void G__cpp_setup_func16() {
34619}
34620
34621static void G__cpp_setup_func17() {
34622}
34623
34624static void G__cpp_setup_func18() {
34625}
34626
34627static void G__cpp_setup_func19() {
34628}
34629
34630static void G__cpp_setup_func20() {
34631}
34632
34633static void G__cpp_setup_func21() {
34634
34635 G__resetifuncposition();
34636}
34637
34638extern "C" void G__cpp_setup_funcRootEventData_rootcint() {
34639 G__cpp_setup_func0();
34640 G__cpp_setup_func1();
34641 G__cpp_setup_func2();
34642 G__cpp_setup_func3();
34643 G__cpp_setup_func4();
34644 G__cpp_setup_func5();
34645 G__cpp_setup_func6();
34646 G__cpp_setup_func7();
34647 G__cpp_setup_func8();
34648 G__cpp_setup_func9();
34649 G__cpp_setup_func10();
34650 G__cpp_setup_func11();
34651 G__cpp_setup_func12();
34652 G__cpp_setup_func13();
34653 G__cpp_setup_func14();
34654 G__cpp_setup_func15();
34655 G__cpp_setup_func16();
34656 G__cpp_setup_func17();
34657 G__cpp_setup_func18();
34658 G__cpp_setup_func19();
34659 G__cpp_setup_func20();
34660 G__cpp_setup_func21();
34661}
34662
34663/*********************************************************
34664* Class,struct,union,enum tag information setup
34665*********************************************************/
34666/* Setup class/struct taginfo */
34667G__linked_taginfo G__RootEventData_rootcintLN_TClass = { "TClass" , 99 , -1 };
34668G__linked_taginfo G__RootEventData_rootcintLN_TBuffer = { "TBuffer" , 99 , -1 };
34669G__linked_taginfo G__RootEventData_rootcintLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
34670G__linked_taginfo G__RootEventData_rootcintLN_TObject = { "TObject" , 99 , -1 };
34671G__linked_taginfo G__RootEventData_rootcintLN_TString = { "TString" , 99 , -1 };
34672G__linked_taginfo G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
34673G__linked_taginfo G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
34674G__linked_taginfo G__RootEventData_rootcintLN_string = { "string" , 99 , -1 };
34675G__linked_taginfo G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
34676G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
34677G__linked_taginfo G__RootEventData_rootcintLN_TObjArray = { "TObjArray" , 99 , -1 };
34678G__linked_taginfo G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
34679G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
34680G__linked_taginfo G__RootEventData_rootcintLN_TJobInfo = { "TJobInfo" , 99 , -1 };
34681G__linked_taginfo G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
34682G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
34683G__linked_taginfo G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
34684G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
34685G__linked_taginfo G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
34686G__linked_taginfo G__RootEventData_rootcintLN_TRawData = { "TRawData" , 99 , -1 };
34687G__linked_taginfo G__RootEventData_rootcintLN_TMdcDigi = { "TMdcDigi" , 99 , -1 };
34688G__linked_taginfo G__RootEventData_rootcintLN_TEmcDigi = { "TEmcDigi" , 99 , -1 };
34689G__linked_taginfo G__RootEventData_rootcintLN_TTofDigi = { "TTofDigi" , 99 , -1 };
34690G__linked_taginfo G__RootEventData_rootcintLN_TMucDigi = { "TMucDigi" , 99 , -1 };
34691G__linked_taginfo G__RootEventData_rootcintLN_TLumiDigi = { "TLumiDigi" , 99 , -1 };
34692G__linked_taginfo G__RootEventData_rootcintLN_TDigiEvent = { "TDigiEvent" , 99 , -1 };
34693G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcTrack = { "TRecMdcTrack" , 99 , -1 };
34694G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcKalTrack = { "TRecMdcKalTrack" , 99 , -1 };
34695G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcHit = { "TRecMdcHit" , 99 , -1 };
34696G__linked_taginfo G__RootEventData_rootcintLN_TTofTrack = { "TTofTrack" , 99 , -1 };
34697G__linked_taginfo G__RootEventData_rootcintLN_TRecTofTrack = { "TRecTofTrack" , 99 , -1 };
34698G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcHit = { "TRecEmcHit" , 99 , -1 };
34699G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcCluster = { "TRecEmcCluster" , 99 , -1 };
34700G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcShower = { "TRecEmcShower" , 99 , -1 };
34701G__linked_taginfo G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR = { "map<int,double,less<int>,allocator<pair<const int,double> > >" , 99 , -1 };
34702G__linked_taginfo G__RootEventData_rootcintLN_TRecMucTrack = { "TRecMucTrack" , 99 , -1 };
34703G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcDedx = { "TRecMdcDedx" , 99 , -1 };
34704G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcDedxHit = { "TRecMdcDedxHit" , 99 , -1 };
34705G__linked_taginfo G__RootEventData_rootcintLN_TRecExtTrack = { "TRecExtTrack" , 99 , -1 };
34706G__linked_taginfo G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
34707G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
34708G__linked_taginfo G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR = { "vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >" , 99 , -1 };
34709G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >::iterator>" , 99 , -1 };
34710G__linked_taginfo G__RootEventData_rootcintLN_TRecEvTime = { "TRecEvTime" , 99 , -1 };
34711G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcKalHelixSeg = { "TRecMdcKalHelixSeg" , 99 , -1 };
34712G__linked_taginfo G__RootEventData_rootcintLN_TRecZddChannel = { "TRecZddChannel" , 99 , -1 };
34713G__linked_taginfo G__RootEventData_rootcintLN_pairlEintcOfloatgR = { "pair<int,float>" , 115 , -1 };
34714G__linked_taginfo G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR = { "vector<pair<int,float>,allocator<pair<int,float> > >" , 99 , -1 };
34715G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<int,float>,allocator<pair<int,float> > >::iterator>" , 99 , -1 };
34716G__linked_taginfo G__RootEventData_rootcintLN_TRecTrackEvent = { "TRecTrackEvent" , 99 , -1 };
34717G__linked_taginfo G__RootEventData_rootcintLN_TMdcTrack = { "TMdcTrack" , 99 , -1 };
34718G__linked_taginfo G__RootEventData_rootcintLN_TEmcTrack = { "TEmcTrack" , 99 , -1 };
34719G__linked_taginfo G__RootEventData_rootcintLN_TMucTrack = { "TMucTrack" , 99 , -1 };
34720G__linked_taginfo G__RootEventData_rootcintLN_TMdcDedx = { "TMdcDedx" , 99 , -1 };
34721G__linked_taginfo G__RootEventData_rootcintLN_TExtTrack = { "TExtTrack" , 99 , -1 };
34722G__linked_taginfo G__RootEventData_rootcintLN_TMdcKalTrack = { "TMdcKalTrack" , 99 , -1 };
34723G__linked_taginfo G__RootEventData_rootcintLN_TDstEvent = { "TDstEvent" , 99 , -1 };
34724G__linked_taginfo G__RootEventData_rootcintLN_TMdcMc = { "TMdcMc" , 99 , -1 };
34725G__linked_taginfo G__RootEventData_rootcintLN_TEmcMc = { "TEmcMc" , 99 , -1 };
34726G__linked_taginfo G__RootEventData_rootcintLN_TTofMc = { "TTofMc" , 99 , -1 };
34727G__linked_taginfo G__RootEventData_rootcintLN_TMucMc = { "TMucMc" , 99 , -1 };
34728G__linked_taginfo G__RootEventData_rootcintLN_TMcParticle = { "TMcParticle" , 99 , -1 };
34729G__linked_taginfo G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits = { "TMcParticle::StatusBits" , 101 , -1 };
34730G__linked_taginfo G__RootEventData_rootcintLN_TMcEvent = { "TMcEvent" , 99 , -1 };
34731G__linked_taginfo G__RootEventData_rootcintLN_TEvtHeader = { "TEvtHeader" , 99 , -1 };
34732G__linked_taginfo G__RootEventData_rootcintLN_TEvtNavigator = { "TEvtNavigator" , 99 , -1 };
34733G__linked_taginfo G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR = { "multimap<int,int,less<int>,allocator<pair<const int,int> > >" , 99 , -1 };
34734G__linked_taginfo G__RootEventData_rootcintLN_TTrigData = { "TTrigData" , 99 , -1 };
34735G__linked_taginfo G__RootEventData_rootcintLN_TTrigEvent = { "TTrigEvent" , 99 , -1 };
34736G__linked_taginfo G__RootEventData_rootcintLN_THltRaw = { "THltRaw" , 99 , -1 };
34737G__linked_taginfo G__RootEventData_rootcintLN_THltInf = { "THltInf" , 99 , -1 };
34738G__linked_taginfo G__RootEventData_rootcintLN_TDstHltInf = { "TDstHltInf" , 99 , -1 };
34739G__linked_taginfo G__RootEventData_rootcintLN_THltEvent = { "THltEvent" , 99 , -1 };
34740G__linked_taginfo G__RootEventData_rootcintLN_TDisTrack = { "TDisTrack" , 99 , -1 };
34741G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecEvent = { "TEvtRecEvent" , 99 , -1 };
34742G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecTrack = { "TEvtRecTrack" , 99 , -1 };
34743G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecPrimaryVertex = { "TEvtRecPrimaryVertex" , 99 , -1 };
34744G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecVeeVertex = { "TEvtRecVeeVertex" , 99 , -1 };
34745G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecPi0 = { "TEvtRecPi0" , 99 , -1 };
34746G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecEtaToGG = { "TEvtRecEtaToGG" , 99 , -1 };
34747G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecDTag = { "TEvtRecDTag" , 99 , -1 };
34748G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecObject = { "TEvtRecObject" , 99 , -1 };
34749G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
34750G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
34751G__linked_taginfo G__RootEventData_rootcintLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
34752G__linked_taginfo G__RootEventData_rootcintLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
34753G__linked_taginfo G__RootEventData_rootcintLN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
34754G__linked_taginfo G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
34755G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
34756G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
34757G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
34758G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
34759G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
34760G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
34761G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
34762G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
34763G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
34764G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
34765G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
34766G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
34767G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
34768G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
34769G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
34770G__linked_taginfo G__RootEventData_rootcintLN_TVector3 = { "TVector3" , 99 , -1 };
34771G__linked_taginfo G__RootEventData_rootcintLN_TMcHitTof = { "TMcHitTof" , 99 , -1 };
34772G__linked_taginfo G__RootEventData_rootcintLN_TMcHitMdc = { "TMcHitMdc" , 99 , -1 };
34773G__linked_taginfo G__RootEventData_rootcintLN_TMcDigiEmc = { "TMcDigiEmc" , 99 , -1 };
34774G__linked_taginfo G__RootEventData_rootcintLN_TMcHitEvent = { "TMcHitEvent" , 99 , -1 };
34775G__linked_taginfo G__RootEventData_rootcintLN_TBossFullEvent = { "TBossFullEvent" , 99 , -1 };
34776G__linked_taginfo G__RootEventData_rootcintLN_TBossFullEventcLcLdA = { "TBossFullEvent::$" , 101 , -1 };
34777
34778/* Reset class/struct taginfo */
34779extern "C" void G__cpp_reset_tagtableRootEventData_rootcint() {
34780 G__RootEventData_rootcintLN_TClass.tagnum = -1 ;
34781 G__RootEventData_rootcintLN_TBuffer.tagnum = -1 ;
34782 G__RootEventData_rootcintLN_TMemberInspector.tagnum = -1 ;
34783 G__RootEventData_rootcintLN_TObject.tagnum = -1 ;
34784 G__RootEventData_rootcintLN_TString.tagnum = -1 ;
34785 G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
34786 G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
34787 G__RootEventData_rootcintLN_string.tagnum = -1 ;
34788 G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
34789 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
34790 G__RootEventData_rootcintLN_TObjArray.tagnum = -1 ;
34791 G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
34792 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
34793 G__RootEventData_rootcintLN_TJobInfo.tagnum = -1 ;
34794 G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
34795 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
34796 G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
34797 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
34798 G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
34799 G__RootEventData_rootcintLN_TRawData.tagnum = -1 ;
34800 G__RootEventData_rootcintLN_TMdcDigi.tagnum = -1 ;
34801 G__RootEventData_rootcintLN_TEmcDigi.tagnum = -1 ;
34802 G__RootEventData_rootcintLN_TTofDigi.tagnum = -1 ;
34803 G__RootEventData_rootcintLN_TMucDigi.tagnum = -1 ;
34804 G__RootEventData_rootcintLN_TLumiDigi.tagnum = -1 ;
34805 G__RootEventData_rootcintLN_TDigiEvent.tagnum = -1 ;
34806 G__RootEventData_rootcintLN_TRecMdcTrack.tagnum = -1 ;
34807 G__RootEventData_rootcintLN_TRecMdcKalTrack.tagnum = -1 ;
34808 G__RootEventData_rootcintLN_TRecMdcHit.tagnum = -1 ;
34809 G__RootEventData_rootcintLN_TTofTrack.tagnum = -1 ;
34810 G__RootEventData_rootcintLN_TRecTofTrack.tagnum = -1 ;
34811 G__RootEventData_rootcintLN_TRecEmcHit.tagnum = -1 ;
34812 G__RootEventData_rootcintLN_TRecEmcCluster.tagnum = -1 ;
34813 G__RootEventData_rootcintLN_TRecEmcShower.tagnum = -1 ;
34814 G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR.tagnum = -1 ;
34815 G__RootEventData_rootcintLN_TRecMucTrack.tagnum = -1 ;
34816 G__RootEventData_rootcintLN_TRecMdcDedx.tagnum = -1 ;
34817 G__RootEventData_rootcintLN_TRecMdcDedxHit.tagnum = -1 ;
34818 G__RootEventData_rootcintLN_TRecExtTrack.tagnum = -1 ;
34819 G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
34820 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
34821 G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR.tagnum = -1 ;
34822 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
34823 G__RootEventData_rootcintLN_TRecEvTime.tagnum = -1 ;
34824 G__RootEventData_rootcintLN_TRecMdcKalHelixSeg.tagnum = -1 ;
34825 G__RootEventData_rootcintLN_TRecZddChannel.tagnum = -1 ;
34826 G__RootEventData_rootcintLN_pairlEintcOfloatgR.tagnum = -1 ;
34827 G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR.tagnum = -1 ;
34828 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
34829 G__RootEventData_rootcintLN_TRecTrackEvent.tagnum = -1 ;
34830 G__RootEventData_rootcintLN_TMdcTrack.tagnum = -1 ;
34831 G__RootEventData_rootcintLN_TEmcTrack.tagnum = -1 ;
34832 G__RootEventData_rootcintLN_TMucTrack.tagnum = -1 ;
34833 G__RootEventData_rootcintLN_TMdcDedx.tagnum = -1 ;
34834 G__RootEventData_rootcintLN_TExtTrack.tagnum = -1 ;
34835 G__RootEventData_rootcintLN_TMdcKalTrack.tagnum = -1 ;
34836 G__RootEventData_rootcintLN_TDstEvent.tagnum = -1 ;
34837 G__RootEventData_rootcintLN_TMdcMc.tagnum = -1 ;
34838 G__RootEventData_rootcintLN_TEmcMc.tagnum = -1 ;
34839 G__RootEventData_rootcintLN_TTofMc.tagnum = -1 ;
34840 G__RootEventData_rootcintLN_TMucMc.tagnum = -1 ;
34841 G__RootEventData_rootcintLN_TMcParticle.tagnum = -1 ;
34842 G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits.tagnum = -1 ;
34843 G__RootEventData_rootcintLN_TMcEvent.tagnum = -1 ;
34844 G__RootEventData_rootcintLN_TEvtHeader.tagnum = -1 ;
34845 G__RootEventData_rootcintLN_TEvtNavigator.tagnum = -1 ;
34846 G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR.tagnum = -1 ;
34847 G__RootEventData_rootcintLN_TTrigData.tagnum = -1 ;
34848 G__RootEventData_rootcintLN_TTrigEvent.tagnum = -1 ;
34849 G__RootEventData_rootcintLN_THltRaw.tagnum = -1 ;
34850 G__RootEventData_rootcintLN_THltInf.tagnum = -1 ;
34851 G__RootEventData_rootcintLN_TDstHltInf.tagnum = -1 ;
34852 G__RootEventData_rootcintLN_THltEvent.tagnum = -1 ;
34853 G__RootEventData_rootcintLN_TDisTrack.tagnum = -1 ;
34854 G__RootEventData_rootcintLN_TEvtRecEvent.tagnum = -1 ;
34855 G__RootEventData_rootcintLN_TEvtRecTrack.tagnum = -1 ;
34856 G__RootEventData_rootcintLN_TEvtRecPrimaryVertex.tagnum = -1 ;
34857 G__RootEventData_rootcintLN_TEvtRecVeeVertex.tagnum = -1 ;
34858 G__RootEventData_rootcintLN_TEvtRecPi0.tagnum = -1 ;
34859 G__RootEventData_rootcintLN_TEvtRecEtaToGG.tagnum = -1 ;
34860 G__RootEventData_rootcintLN_TEvtRecDTag.tagnum = -1 ;
34861 G__RootEventData_rootcintLN_TEvtRecObject.tagnum = -1 ;
34862 G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
34863 G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
34864 G__RootEventData_rootcintLN_TVectorTlEfloatgR.tagnum = -1 ;
34865 G__RootEventData_rootcintLN_TVectorTlEdoublegR.tagnum = -1 ;
34866 G__RootEventData_rootcintLN_TElementActionTlEfloatgR.tagnum = -1 ;
34867 G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR.tagnum = -1 ;
34868 G__RootEventData_rootcintLN_TMatrixTlEfloatgR.tagnum = -1 ;
34869 G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
34870 G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR.tagnum = -1 ;
34871 G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
34872 G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
34873 G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
34874 G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
34875 G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
34876 G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
34877 G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
34878 G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
34879 G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
34880 G__RootEventData_rootcintLN_TMatrixTSublEfloatgR.tagnum = -1 ;
34881 G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
34882 G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
34883 G__RootEventData_rootcintLN_TVector3.tagnum = -1 ;
34884 G__RootEventData_rootcintLN_TMcHitTof.tagnum = -1 ;
34885 G__RootEventData_rootcintLN_TMcHitMdc.tagnum = -1 ;
34886 G__RootEventData_rootcintLN_TMcDigiEmc.tagnum = -1 ;
34887 G__RootEventData_rootcintLN_TMcHitEvent.tagnum = -1 ;
34888 G__RootEventData_rootcintLN_TBossFullEvent.tagnum = -1 ;
34889 G__RootEventData_rootcintLN_TBossFullEventcLcLdA.tagnum = -1 ;
34890}
34891
34892
34893extern "C" void G__cpp_setup_tagtableRootEventData_rootcint() {
34894
34895 /* Setting up class,struct,union tag entry */
34896 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TClass);
34897 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TBuffer);
34898 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMemberInspector);
34899 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TObject);
34900 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TString);
34901 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR);
34902 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
34903 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_string);
34904 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
34905 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
34906 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TObjArray);
34907 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
34908 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
34909 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TJobInfo),sizeof(TJobInfo),-1,292096,(char*)NULL,G__setup_memvarTJobInfo,G__setup_memfuncTJobInfo);
34910 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR);
34911 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
34912 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR);
34913 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
34914 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
34915 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRawData),sizeof(TRawData),-1,292096,(char*)NULL,G__setup_memvarTRawData,G__setup_memfuncTRawData);
34916 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcDigi),sizeof(TMdcDigi),-1,292096,(char*)NULL,G__setup_memvarTMdcDigi,G__setup_memfuncTMdcDigi);
34917 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEmcDigi),sizeof(TEmcDigi),-1,292096,(char*)NULL,G__setup_memvarTEmcDigi,G__setup_memfuncTEmcDigi);
34918 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTofDigi),sizeof(TTofDigi),-1,292096,(char*)NULL,G__setup_memvarTTofDigi,G__setup_memfuncTTofDigi);
34919 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMucDigi),sizeof(TMucDigi),-1,292096,(char*)NULL,G__setup_memvarTMucDigi,G__setup_memfuncTMucDigi);
34920 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TLumiDigi),sizeof(TLumiDigi),-1,292096,(char*)NULL,G__setup_memvarTLumiDigi,G__setup_memfuncTLumiDigi);
34921 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);
34922 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcTrack),sizeof(TRecMdcTrack),-1,292096,(char*)NULL,G__setup_memvarTRecMdcTrack,G__setup_memfuncTRecMdcTrack);
34923 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcKalTrack),sizeof(TRecMdcKalTrack),-1,292096,(char*)NULL,G__setup_memvarTRecMdcKalTrack,G__setup_memfuncTRecMdcKalTrack);
34924 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcHit),sizeof(TRecMdcHit),-1,292096,(char*)NULL,G__setup_memvarTRecMdcHit,G__setup_memfuncTRecMdcHit);
34925 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTofTrack),sizeof(TTofTrack),-1,292096,(char*)NULL,G__setup_memvarTTofTrack,G__setup_memfuncTTofTrack);
34926 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecTofTrack),sizeof(TRecTofTrack),-1,292096,(char*)NULL,G__setup_memvarTRecTofTrack,G__setup_memfuncTRecTofTrack);
34927 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecEmcHit),sizeof(TRecEmcHit),-1,292096,(char*)NULL,G__setup_memvarTRecEmcHit,G__setup_memfuncTRecEmcHit);
34928 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecEmcCluster),sizeof(TRecEmcCluster),-1,292096,(char*)NULL,G__setup_memvarTRecEmcCluster,G__setup_memfuncTRecEmcCluster);
34929 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecEmcShower),sizeof(TRecEmcShower),-1,292096,(char*)NULL,G__setup_memvarTRecEmcShower,G__setup_memfuncTRecEmcShower);
34930 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR);
34931 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMucTrack),sizeof(TRecMucTrack),-1,292096,(char*)NULL,G__setup_memvarTRecMucTrack,G__setup_memfuncTRecMucTrack);
34932 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcDedx),sizeof(TRecMdcDedx),-1,292096,(char*)NULL,G__setup_memvarTRecMdcDedx,G__setup_memfuncTRecMdcDedx);
34933 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcDedxHit),sizeof(TRecMdcDedxHit),-1,292096,(char*)NULL,G__setup_memvarTRecMdcDedxHit,G__setup_memfuncTRecMdcDedxHit);
34934 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecExtTrack),sizeof(TRecExtTrack),-1,292096,(char*)NULL,G__setup_memvarTRecExtTrack,G__setup_memfuncTRecExtTrack);
34935 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR);
34936 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
34937 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR);
34938 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR);
34939 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecEvTime),sizeof(TRecEvTime),-1,292096,(char*)NULL,G__setup_memvarTRecEvTime,G__setup_memfuncTRecEvTime);
34940 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg),sizeof(TRecMdcKalHelixSeg),-1,292096,(char*)NULL,G__setup_memvarTRecMdcKalHelixSeg,G__setup_memfuncTRecMdcKalHelixSeg);
34941 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecZddChannel),sizeof(TRecZddChannel),-1,292096,(char*)NULL,G__setup_memvarTRecZddChannel,G__setup_memfuncTRecZddChannel);
34942 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_pairlEintcOfloatgR);
34943 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR);
34944 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR);
34945 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecTrackEvent),sizeof(TRecTrackEvent),-1,292096,(char*)NULL,G__setup_memvarTRecTrackEvent,G__setup_memfuncTRecTrackEvent);
34946 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcTrack),sizeof(TMdcTrack),-1,292096,(char*)NULL,G__setup_memvarTMdcTrack,G__setup_memfuncTMdcTrack);
34947 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEmcTrack),sizeof(TEmcTrack),-1,292096,(char*)NULL,G__setup_memvarTEmcTrack,G__setup_memfuncTEmcTrack);
34948 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMucTrack),sizeof(TMucTrack),-1,292096,(char*)NULL,G__setup_memvarTMucTrack,G__setup_memfuncTMucTrack);
34949 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcDedx),sizeof(TMdcDedx),-1,292096,(char*)NULL,G__setup_memvarTMdcDedx,G__setup_memfuncTMdcDedx);
34950 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TExtTrack),sizeof(TExtTrack),-1,292096,(char*)NULL,G__setup_memvarTExtTrack,G__setup_memfuncTExtTrack);
34951 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcKalTrack),sizeof(TMdcKalTrack),-1,292096,(char*)NULL,G__setup_memvarTMdcKalTrack,G__setup_memfuncTMdcKalTrack);
34952 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TDstEvent),sizeof(TDstEvent),-1,292096,(char*)NULL,G__setup_memvarTDstEvent,G__setup_memfuncTDstEvent);
34953 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcMc),sizeof(TMdcMc),-1,292096,(char*)NULL,G__setup_memvarTMdcMc,G__setup_memfuncTMdcMc);
34954 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEmcMc),sizeof(TEmcMc),-1,292096,(char*)NULL,G__setup_memvarTEmcMc,G__setup_memfuncTEmcMc);
34955 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTofMc),sizeof(TTofMc),-1,292096,(char*)NULL,G__setup_memvarTTofMc,G__setup_memfuncTTofMc);
34956 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMucMc),sizeof(TMucMc),-1,292096,(char*)NULL,G__setup_memvarTMucMc,G__setup_memfuncTMucMc);
34957 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcParticle),sizeof(TMcParticle),-1,292096,(char*)NULL,G__setup_memvarTMcParticle,G__setup_memfuncTMcParticle);
34958 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits);
34959 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);
34960 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtHeader),sizeof(TEvtHeader),-1,292096,(char*)NULL,G__setup_memvarTEvtHeader,G__setup_memfuncTEvtHeader);
34961 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtNavigator),sizeof(TEvtNavigator),-1,292096,(char*)NULL,G__setup_memvarTEvtNavigator,G__setup_memfuncTEvtNavigator);
34962 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR);
34963 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTrigData),sizeof(TTrigData),-1,292096,(char*)NULL,G__setup_memvarTTrigData,G__setup_memfuncTTrigData);
34964 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);
34965 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_THltRaw),sizeof(THltRaw),-1,292096,(char*)NULL,G__setup_memvarTHltRaw,G__setup_memfuncTHltRaw);
34966 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_THltInf),sizeof(THltInf),-1,292096,(char*)NULL,G__setup_memvarTHltInf,G__setup_memfuncTHltInf);
34967 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TDstHltInf),sizeof(TDstHltInf),-1,292096,(char*)NULL,G__setup_memvarTDstHltInf,G__setup_memfuncTDstHltInf);
34968 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);
34969 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TDisTrack),sizeof(TDisTrack),-1,29952,(char*)NULL,G__setup_memvarTDisTrack,G__setup_memfuncTDisTrack);
34970 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecEvent),sizeof(TEvtRecEvent),-1,292096,(char*)NULL,G__setup_memvarTEvtRecEvent,G__setup_memfuncTEvtRecEvent);
34971 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecTrack),sizeof(TEvtRecTrack),-1,292096,(char*)NULL,G__setup_memvarTEvtRecTrack,G__setup_memfuncTEvtRecTrack);
34972 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex),sizeof(TEvtRecPrimaryVertex),-1,292096,(char*)NULL,G__setup_memvarTEvtRecPrimaryVertex,G__setup_memfuncTEvtRecPrimaryVertex);
34973 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecVeeVertex),sizeof(TEvtRecVeeVertex),-1,292096,(char*)NULL,G__setup_memvarTEvtRecVeeVertex,G__setup_memfuncTEvtRecVeeVertex);
34974 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecPi0),sizeof(TEvtRecPi0),-1,292096,(char*)NULL,G__setup_memvarTEvtRecPi0,G__setup_memfuncTEvtRecPi0);
34975 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecEtaToGG),sizeof(TEvtRecEtaToGG),-1,292096,(char*)NULL,G__setup_memvarTEvtRecEtaToGG,G__setup_memfuncTEvtRecEtaToGG);
34976 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecDTag),sizeof(TEvtRecDTag),-1,292096,(char*)NULL,G__setup_memvarTEvtRecDTag,G__setup_memfuncTEvtRecDTag);
34977 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecObject),sizeof(TEvtRecObject),-1,292096,(char*)NULL,G__setup_memvarTEvtRecObject,G__setup_memfuncTEvtRecObject);
34978 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR);
34979 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR);
34980 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TVectorTlEfloatgR);
34981 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TVectorTlEdoublegR);
34982 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TElementActionTlEfloatgR);
34983 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR);
34984 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTlEfloatgR);
34985 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR);
34986 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR);
34987 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR);
34988 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR);
34989 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR);
34990 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR);
34991 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR);
34992 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR);
34993 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR);
34994 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR);
34995 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR);
34996 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSublEfloatgR);
34997 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR);
34998 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR);
34999 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TVector3);
35000 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcHitTof),sizeof(TMcHitTof),-1,292096,(char*)NULL,G__setup_memvarTMcHitTof,G__setup_memfuncTMcHitTof);
35001 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcHitMdc),sizeof(TMcHitMdc),-1,292096,(char*)NULL,G__setup_memvarTMcHitMdc,G__setup_memfuncTMcHitMdc);
35002 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcDigiEmc),sizeof(TMcDigiEmc),-1,292096,(char*)NULL,G__setup_memvarTMcDigiEmc,G__setup_memfuncTMcDigiEmc);
35003 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);
35004 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TBossFullEvent),sizeof(TBossFullEvent),-1,95488,(char*)NULL,G__setup_memvarTBossFullEvent,G__setup_memfuncTBossFullEvent);
35005 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA);
35006}
35007extern "C" void G__cpp_setupRootEventData_rootcint(void) {
35008 G__check_setup_version(30051515,"G__cpp_setupRootEventData_rootcint()");
35009 G__set_cpp_environmentRootEventData_rootcint();
35010 G__cpp_setup_tagtableRootEventData_rootcint();
35011
35012 G__cpp_setup_inheritanceRootEventData_rootcint();
35013
35014 G__cpp_setup_typetableRootEventData_rootcint();
35015
35016 G__cpp_setup_memvarRootEventData_rootcint();
35017
35018 G__cpp_setup_memfuncRootEventData_rootcint();
35019 G__cpp_setup_globalRootEventData_rootcint();
35020 G__cpp_setup_funcRootEventData_rootcint();
35021
35022 if(0==G__getsizep2memfunc()) G__get_sizep2memfuncRootEventData_rootcint();
35023 return;
35024}
35025class G__cpp_setup_initRootEventData_rootcint {
35026 public:
35027 G__cpp_setup_initRootEventData_rootcint() { G__add_setup_func("RootEventData_rootcint",(G__incsetup)(&G__cpp_setupRootEventData_rootcint)); G__call_setup_funcs(); }
35028 ~G__cpp_setup_initRootEventData_rootcint() { G__remove_setup_func("RootEventData_rootcint"); }
35029};
35030G__cpp_setup_initRootEventData_rootcint G__cpp_setup_initializerRootEventData_rootcint;
35031
mass
double mass
Definition: CosmicGenerator.cxx:138
sigma
TTree * sigma
Definition: CurConst_dEdXCal.cxx:6
w
double w
Definition: EvtPhokharaDef.hh:26
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__RootEventData_rootcintLN_TEvtRecEvent
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecEvent
Definition: RootEventData_rootcint.cxx:34741
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR
Definition: RootEventData_rootcint.cxx:34682
G__RootEventData_rootcintLN_TMucMc
G__linked_taginfo G__RootEventData_rootcintLN_TMucMc
Definition: RootEventData_rootcint.cxx:34727
G__RootEventData_rootcintLN_TMucDigi
G__linked_taginfo G__RootEventData_rootcintLN_TMucDigi
Definition: RootEventData_rootcint.cxx:34690
G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR
Definition: RootEventData_rootcint.cxx:34673
G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR
Definition: RootEventData_rootcint.cxx:34750
G__TTEmcTrack
TEmcTrack G__TTEmcTrack
Definition: RootEventData_rootcint.cxx:18658
G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR
Definition: RootEventData_rootcint.cxx:34706
G__cpp_setup_typetableRootEventData_rootcint
void G__cpp_setup_typetableRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:29605
G__RootEventData_rootcintLN_TRecEmcHit
G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcHit
Definition: RootEventData_rootcint.cxx:34698
G__RootEventData_rootcintLN_TRecMdcHit
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcHit
Definition: RootEventData_rootcint.cxx:34695
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR
Definition: RootEventData_rootcint.cxx:34715
G__RootEventData_rootcintLN_TBuffer
G__linked_taginfo G__RootEventData_rootcintLN_TBuffer
Definition: RootEventData_rootcint.cxx:34668
G__RootEventData_rootcintLN_TVectorTlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TVectorTlEfloatgR
Definition: RootEventData_rootcint.cxx:34751
G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR
Definition: RootEventData_rootcint.cxx:34681
G__TTEvtRecPrimaryVertex
TEvtRecPrimaryVertex G__TTEvtRecPrimaryVertex
Definition: RootEventData_rootcint.cxx:25919
G__TTRecTofTrack
TRecTofTrack G__TTRecTofTrack
Definition: RootEventData_rootcint.cxx:12332
G__RootEventData_rootcintLN_TMucTrack
G__linked_taginfo G__RootEventData_rootcintLN_TMucTrack
Definition: RootEventData_rootcint.cxx:34719
G__RootEventData_rootcintLN_TMatrixTSublEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSublEfloatgR
Definition: RootEventData_rootcint.cxx:34767
G__RootEventData_rootcintLN_TRecZddChannel
G__linked_taginfo G__RootEventData_rootcintLN_TRecZddChannel
Definition: RootEventData_rootcint.cxx:34712
G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR
Definition: RootEventData_rootcint.cxx:34733
G__cpp_setupRootEventData_rootcint
void G__cpp_setupRootEventData_rootcint(void)
Definition: RootEventData_rootcint.cxx:35007
G__cpp_setup_inheritanceRootEventData_rootcint
void G__cpp_setup_inheritanceRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:29101
G__TTEvtRecPi0
TEvtRecPi0 G__TTEvtRecPi0
Definition: RootEventData_rootcint.cxx:26506
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR
Definition: RootEventData_rootcint.cxx:34707
G__RootEventData_rootcintLN_TVectorTlEdoublegR
G__linked_taginfo G__RootEventData_rootcintLN_TVectorTlEdoublegR
Definition: RootEventData_rootcint.cxx:34752
G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR
Definition: RootEventData_rootcint.cxx:34675
G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR
Definition: RootEventData_rootcint.cxx:34762
G__RootEventData_rootcintLN_TRecExtTrack
G__linked_taginfo G__RootEventData_rootcintLN_TRecExtTrack
Definition: RootEventData_rootcint.cxx:34705
G__TTRecExtTrack
TRecExtTrack G__TTRecExtTrack
Definition: RootEventData_rootcint.cxx:16628
G__TTDisTrack
TDisTrack G__TTDisTrack
Definition: RootEventData_rootcint.cxx:25140
G__RootEventData_rootcintLN_TTrigEvent
G__linked_taginfo G__RootEventData_rootcintLN_TTrigEvent
Definition: RootEventData_rootcint.cxx:34735
G__set_cpp_environmentRootEventData_rootcint
void G__set_cpp_environmentRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:7830
G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR
Definition: RootEventData_rootcint.cxx:34754
G__RootEventData_rootcintLN_TTofMc
G__linked_taginfo G__RootEventData_rootcintLN_TTofMc
Definition: RootEventData_rootcint.cxx:34726
G__RootEventData_rootcintLN_TMemberInspector
G__linked_taginfo G__RootEventData_rootcintLN_TMemberInspector
Definition: RootEventData_rootcint.cxx:34669
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR
Definition: RootEventData_rootcint.cxx:34679
G__TTDigiEvent
TDigiEvent G__TTDigiEvent
Definition: RootEventData_rootcint.cxx:9343
G__TTRecEmcCluster
TRecEmcCluster G__TTRecEmcCluster
Definition: RootEventData_rootcint.cxx:12732
G__TTRecEmcShower
TRecEmcShower G__TTRecEmcShower
Definition: RootEventData_rootcint.cxx:13281
G__TTEvtRecDTag
TEvtRecDTag G__TTEvtRecDTag
Definition: RootEventData_rootcint.cxx:27263
G__RootEventData_rootcintLN_TRecEmcShower
G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcShower
Definition: RootEventData_rootcint.cxx:34700
G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR
Definition: RootEventData_rootcint.cxx:34759
G__cpp_setup_funcRootEventData_rootcint
void G__cpp_setup_funcRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:34638
G__TTEvtRecVeeVertex
TEvtRecVeeVertex G__TTEvtRecVeeVertex
Definition: RootEventData_rootcint.cxx:26206
G__TTTofDigi
TTofDigi G__TTTofDigi
Definition: RootEventData_rootcint.cxx:8747
G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR
Definition: RootEventData_rootcint.cxx:34765
G__RootEventData_rootcintLN_TEvtRecTrack
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecTrack
Definition: RootEventData_rootcint.cxx:34742
G__cpp_setup_globalRootEventData_rootcint
void G__cpp_setup_globalRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:34559
G__TTMcDigiEmc
TMcDigiEmc G__TTMcDigiEmc
Definition: RootEventData_rootcint.cxx:28420
G__RootEventData_rootcintLN_TMatrixTlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTlEfloatgR
Definition: RootEventData_rootcint.cxx:34755
G__RootEventData_rootcintLN_TEvtRecPi0
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecPi0
Definition: RootEventData_rootcint.cxx:34745
G__RootEventData_rootcintLN_TRecEmcCluster
G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcCluster
Definition: RootEventData_rootcint.cxx:34699
G__RootEventData_rootcintLN_TRecMucTrack
G__linked_taginfo G__RootEventData_rootcintLN_TRecMucTrack
Definition: RootEventData_rootcint.cxx:34702
G__TTRawData
TRawData G__TTRawData
Definition: RootEventData_rootcint.cxx:8276
G__TTMucDigi
TMucDigi G__TTMucDigi
Definition: RootEventData_rootcint.cxx:8891
G__RootEventData_rootcintLN_TRecMdcDedxHit
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcDedxHit
Definition: RootEventData_rootcint.cxx:34704
G__TTDstHltInf
TDstHltInf G__TTDstHltInf
Definition: RootEventData_rootcint.cxx:24612
G__RootEventData_rootcintLN_TRecMdcTrack
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcTrack
Definition: RootEventData_rootcint.cxx:34693
G__RootEventData_rootcintLN_TEvtRecVeeVertex
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecVeeVertex
Definition: RootEventData_rootcint.cxx:34744
G__RootEventData_rootcintLN_TDstHltInf
G__linked_taginfo G__RootEventData_rootcintLN_TDstHltInf
Definition: RootEventData_rootcint.cxx:34738
G__cpp_setup_memvarRootEventData_rootcint
void G__cpp_setup_memvarRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:31154
G__TTEvtNavigator
TEvtNavigator G__TTEvtNavigator
Definition: RootEventData_rootcint.cxx:23492
G__RootEventData_rootcintLN_TRecTrackEvent
G__linked_taginfo G__RootEventData_rootcintLN_TRecTrackEvent
Definition: RootEventData_rootcint.cxx:34716
G__TTEvtHeader
TEvtHeader G__TTEvtHeader
Definition: RootEventData_rootcint.cxx:23320
G__TTBossFullEvent
TBossFullEvent G__TTBossFullEvent
Definition: RootEventData_rootcint.cxx:28896
G__TTRecZddChannel
TRecZddChannel G__TTRecZddChannel
Definition: RootEventData_rootcint.cxx:17350
G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR
G__linked_taginfo G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR
Definition: RootEventData_rootcint.cxx:34685
G__RootEventData_rootcintLN_string
G__linked_taginfo G__RootEventData_rootcintLN_string
Definition: RootEventData_rootcint.cxx:34674
G__TTTofTrack
TTofTrack G__TTTofTrack
Definition: RootEventData_rootcint.cxx:11687
G__TTRecTrackEvent
TRecTrackEvent G__TTRecTrackEvent
Definition: RootEventData_rootcint.cxx:17865
G__RootEventData_rootcintLN_THltInf
G__linked_taginfo G__RootEventData_rootcintLN_THltInf
Definition: RootEventData_rootcint.cxx:34737
G__TTHltEvent
THltEvent G__TTHltEvent
Definition: RootEventData_rootcint.cxx:24829
G__RootEventData_rootcintLN_TRawData
G__linked_taginfo G__RootEventData_rootcintLN_TRawData
Definition: RootEventData_rootcint.cxx:34686
G__get_sizep2memfuncRootEventData_rootcint
size_t G__get_sizep2memfuncRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:29084
G__TTRecMdcDedxHit
TRecMdcDedxHit G__TTRecMdcDedxHit
Definition: RootEventData_rootcint.cxx:14612
G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR
Definition: RootEventData_rootcint.cxx:34766
G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR
Definition: RootEventData_rootcint.cxx:34768
G__TTTofMc
TTofMc G__TTTofMc
Definition: RootEventData_rootcint.cxx:22134
G__RootEventData_rootcintLN_TTrigData
G__linked_taginfo G__RootEventData_rootcintLN_TTrigData
Definition: RootEventData_rootcint.cxx:34734
G__RootEventData_rootcintLN_TExtTrack
G__linked_taginfo G__RootEventData_rootcintLN_TExtTrack
Definition: RootEventData_rootcint.cxx:34721
G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits
G__linked_taginfo G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits
Definition: RootEventData_rootcint.cxx:34729
G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR
Definition: RootEventData_rootcint.cxx:34678
G__RootEventData_rootcintLN_TRecTofTrack
G__linked_taginfo G__RootEventData_rootcintLN_TRecTofTrack
Definition: RootEventData_rootcint.cxx:34697
G__TTEmcDigi
TEmcDigi G__TTEmcDigi
Definition: RootEventData_rootcint.cxx:8590
G__RootEventData_rootcintLN_TMcHitEvent
G__linked_taginfo G__RootEventData_rootcintLN_TMcHitEvent
Definition: RootEventData_rootcint.cxx:34774
G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR
Definition: RootEventData_rootcint.cxx:34714
G__RootEventData_rootcintLN_TMcDigiEmc
G__linked_taginfo G__RootEventData_rootcintLN_TMcDigiEmc
Definition: RootEventData_rootcint.cxx:34773
G__RootEventData_rootcintLN_THltEvent
G__linked_taginfo G__RootEventData_rootcintLN_THltEvent
Definition: RootEventData_rootcint.cxx:34739
G__cpp_dllrevRootEventData_rootcint
int G__cpp_dllrevRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:7893
G__RootEventData_rootcintLN_TEmcTrack
G__linked_taginfo G__RootEventData_rootcintLN_TEmcTrack
Definition: RootEventData_rootcint.cxx:34718
G__TTHltInf
THltInf G__TTHltInf
Definition: RootEventData_rootcint.cxx:24377
G__RootEventData_rootcintLN_pairlEintcOfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_pairlEintcOfloatgR
Definition: RootEventData_rootcint.cxx:34713
G__RootEventData_rootcintLN_TRecEvTime
G__linked_taginfo G__RootEventData_rootcintLN_TRecEvTime
Definition: RootEventData_rootcint.cxx:34710
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR
Definition: RootEventData_rootcint.cxx:34676
G__TTRecMdcDedx
TRecMdcDedx G__TTRecMdcDedx
Definition: RootEventData_rootcint.cxx:14364
G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR
Definition: RootEventData_rootcint.cxx:34749
G__TTRecMdcKalTrack
TRecMdcKalTrack G__TTRecMdcKalTrack
Definition: RootEventData_rootcint.cxx:10664
G__RootEventData_rootcintLN_TObjArray
G__linked_taginfo G__RootEventData_rootcintLN_TObjArray
Definition: RootEventData_rootcint.cxx:34677
G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR
Definition: RootEventData_rootcint.cxx:34757
G__cpp_setup_tagtableRootEventData_rootcint
void G__cpp_setup_tagtableRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:34893
G__RootEventData_rootcintLN_TElementActionTlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TElementActionTlEfloatgR
Definition: RootEventData_rootcint.cxx:34753
G__TTMucTrack
TMucTrack G__TTMucTrack
Definition: RootEventData_rootcint.cxx:19205
G__RootEventData_rootcintLN_TBossFullEventcLcLdA
G__linked_taginfo G__RootEventData_rootcintLN_TBossFullEventcLcLdA
Definition: RootEventData_rootcint.cxx:34776
G__RootEventData_rootcintLN_TEmcMc
G__linked_taginfo G__RootEventData_rootcintLN_TEmcMc
Definition: RootEventData_rootcint.cxx:34725
G__TTExtTrack
TExtTrack G__TTExtTrack
Definition: RootEventData_rootcint.cxx:20454
G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR
Definition: RootEventData_rootcint.cxx:34701
G__TTMucMc
TMucMc G__TTMucMc
Definition: RootEventData_rootcint.cxx:22382
G__RootEventData_rootcintLN_TObject
G__linked_taginfo G__RootEventData_rootcintLN_TObject
Definition: RootEventData_rootcint.cxx:34670
G__RootEventData_rootcintLN_TMdcMc
G__linked_taginfo G__RootEventData_rootcintLN_TMdcMc
Definition: RootEventData_rootcint.cxx:34724
G__RootEventData_rootcintLN_TTofDigi
G__linked_taginfo G__RootEventData_rootcintLN_TTofDigi
Definition: RootEventData_rootcint.cxx:34689
G__TTRecEmcHit
TRecEmcHit G__TTRecEmcHit
Definition: RootEventData_rootcint.cxx:12515
G__RootEventData_rootcintLN_TMdcDigi
G__linked_taginfo G__RootEventData_rootcintLN_TMdcDigi
Definition: RootEventData_rootcint.cxx:34687
G__TTTrigEvent
TTrigEvent G__TTTrigEvent
Definition: RootEventData_rootcint.cxx:23898
G__TTMdcTrack
TMdcTrack G__TTMdcTrack
Definition: RootEventData_rootcint.cxx:18211
G__TTHltRaw
THltRaw G__TTHltRaw
Definition: RootEventData_rootcint.cxx:24042
G__TTEvtRecEvent
TEvtRecEvent G__TTEvtRecEvent
Definition: RootEventData_rootcint.cxx:25382
G__TTEmcMc
TEmcMc G__TTEmcMc
Definition: RootEventData_rootcint.cxx:21860
G__cpp_reset_tagtableRootEventData_rootcint
void G__cpp_reset_tagtableRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:34779
G__TTMcEvent
TMcEvent G__TTMcEvent
Definition: RootEventData_rootcint.cxx:23085
G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR
Definition: RootEventData_rootcint.cxx:34764
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR
Definition: RootEventData_rootcint.cxx:34684
G__RootEventData_rootcintLN_TJobInfo
G__linked_taginfo G__RootEventData_rootcintLN_TJobInfo
Definition: RootEventData_rootcint.cxx:34680
G__TTTrigData
TTrigData G__TTTrigData
Definition: RootEventData_rootcint.cxx:23727
G__RootEventData_rootcintLN_TBossFullEvent
G__linked_taginfo G__RootEventData_rootcintLN_TBossFullEvent
Definition: RootEventData_rootcint.cxx:34775
G__TTMcHitEvent
TMcHitEvent G__TTMcHitEvent
Definition: RootEventData_rootcint.cxx:28634
G__TTMdcDigi
TMdcDigi G__TTMdcDigi
Definition: RootEventData_rootcint.cxx:8433
G__RootEventData_rootcintLN_TEvtRecDTag
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecDTag
Definition: RootEventData_rootcint.cxx:34747
G__cpp_setup_initializerRootEventData_rootcint
G__cpp_setup_initRootEventData_rootcint G__cpp_setup_initializerRootEventData_rootcint
Definition: RootEventData_rootcint.cxx:35030
G__RootEventData_rootcintLN_TMcHitTof
G__linked_taginfo G__RootEventData_rootcintLN_TMcHitTof
Definition: RootEventData_rootcint.cxx:34771
G__RootEventData_rootcintLN_TMdcKalTrack
G__linked_taginfo G__RootEventData_rootcintLN_TMdcKalTrack
Definition: RootEventData_rootcint.cxx:34722
G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR
Definition: RootEventData_rootcint.cxx:34769
G__RootEventData_rootcintLN_TEvtRecPrimaryVertex
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecPrimaryVertex
Definition: RootEventData_rootcint.cxx:34743
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR
Definition: RootEventData_rootcint.cxx:34709
G__RootEventData_rootcintLN_TEvtNavigator
G__linked_taginfo G__RootEventData_rootcintLN_TEvtNavigator
Definition: RootEventData_rootcint.cxx:34732
G__RootEventData_rootcintLN_TRecMdcDedx
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcDedx
Definition: RootEventData_rootcint.cxx:34703
G__RootEventData_rootcintLN_TTofTrack
G__linked_taginfo G__RootEventData_rootcintLN_TTofTrack
Definition: RootEventData_rootcint.cxx:34696
G__RootEventData_rootcintLN_TDstEvent
G__linked_taginfo G__RootEventData_rootcintLN_TDstEvent
Definition: RootEventData_rootcint.cxx:34723
G__TTEvtRecObject
TEvtRecObject G__TTEvtRecObject
Definition: RootEventData_rootcint.cxx:27570
G__RootEventData_rootcintLN_TDisTrack
G__linked_taginfo G__RootEventData_rootcintLN_TDisTrack
Definition: RootEventData_rootcint.cxx:34740
G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR
Definition: RootEventData_rootcint.cxx:34760
G__TTMdcKalTrack
TMdcKalTrack G__TTMdcKalTrack
Definition: RootEventData_rootcint.cxx:20946
G__RootEventData_rootcintLN_TEvtRecObject
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecObject
Definition: RootEventData_rootcint.cxx:34748
G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR
Definition: RootEventData_rootcint.cxx:34672
G__TTMcHitTof
TMcHitTof G__TTMcHitTof
Definition: RootEventData_rootcint.cxx:27904
G__TTRecMdcTrack
TRecMdcTrack G__TTRecMdcTrack
Definition: RootEventData_rootcint.cxx:9735
G__RootEventData_rootcintLN_TEvtHeader
G__linked_taginfo G__RootEventData_rootcintLN_TEvtHeader
Definition: RootEventData_rootcint.cxx:34731
G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR
Definition: RootEventData_rootcint.cxx:34756
G__RootEventData_rootcintLN_TLumiDigi
G__linked_taginfo G__RootEventData_rootcintLN_TLumiDigi
Definition: RootEventData_rootcint.cxx:34691
G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR
Definition: RootEventData_rootcint.cxx:34708
G__TTLumiDigi
TLumiDigi G__TTLumiDigi
Definition: RootEventData_rootcint.cxx:9048
G__RootEventData_rootcintLN_TRecMdcKalHelixSeg
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcKalHelixSeg
Definition: RootEventData_rootcint.cxx:34711
G__TTRecMdcKalHelixSeg
TRecMdcKalHelixSeg G__TTRecMdcKalHelixSeg
Definition: RootEventData_rootcint.cxx:17137
G__TTMcParticle
TMcParticle G__TTMcParticle
Definition: RootEventData_rootcint.cxx:22804
G__TTJobInfo
TJobInfo G__TTJobInfo
Definition: RootEventData_rootcint.cxx:8081
G__RootEventData_rootcintLN_TMcParticle
G__linked_taginfo G__RootEventData_rootcintLN_TMcParticle
Definition: RootEventData_rootcint.cxx:34728
G__TTRecEvTime
TRecEvTime G__TTRecEvTime
Definition: RootEventData_rootcint.cxx:16811
G__TTRecMdcHit
TRecMdcHit G__TTRecMdcHit
Definition: RootEventData_rootcint.cxx:11049
G__RootEventData_rootcintLN_TMcEvent
G__linked_taginfo G__RootEventData_rootcintLN_TMcEvent
Definition: RootEventData_rootcint.cxx:34730
G__RootEventData_rootcintLN_TEvtRecEtaToGG
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecEtaToGG
Definition: RootEventData_rootcint.cxx:34746
G__TTMcHitMdc
TMcHitMdc G__TTMcHitMdc
Definition: RootEventData_rootcint.cxx:28198
G__TTDstEvent
TDstEvent G__TTDstEvent
Definition: RootEventData_rootcint.cxx:21279
G__TTMdcDedx
TMdcDedx G__TTMdcDedx
Definition: RootEventData_rootcint.cxx:19550
G__TTMdcMc
TMdcMc G__TTMdcMc
Definition: RootEventData_rootcint.cxx:21527
G__RootEventData_rootcintLN_TRecMdcKalTrack
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcKalTrack
Definition: RootEventData_rootcint.cxx:34694
G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR
Definition: RootEventData_rootcint.cxx:34683
G__RootEventData_rootcintLN_TMcHitMdc
G__linked_taginfo G__RootEventData_rootcintLN_TMcHitMdc
Definition: RootEventData_rootcint.cxx:34772
G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR
Definition: RootEventData_rootcint.cxx:34761
G__RootEventData_rootcintLN_TString
G__linked_taginfo G__RootEventData_rootcintLN_TString
Definition: RootEventData_rootcint.cxx:34671
G__RootEventData_rootcintLN_TVector3
G__linked_taginfo G__RootEventData_rootcintLN_TVector3
Definition: RootEventData_rootcint.cxx:34770
G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR
Definition: RootEventData_rootcint.cxx:34758
G__TTEvtRecEtaToGG
TEvtRecEtaToGG G__TTEvtRecEtaToGG
Definition: RootEventData_rootcint.cxx:26806
G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR
Definition: RootEventData_rootcint.cxx:34763
G__RootEventData_rootcintLN_TClass
G__linked_taginfo G__RootEventData_rootcintLN_TClass
Definition: RootEventData_rootcint.cxx:34667
G__RootEventData_rootcintLN_TMdcTrack
G__linked_taginfo G__RootEventData_rootcintLN_TMdcTrack
Definition: RootEventData_rootcint.cxx:34717
G__RootEventData_rootcintLN_TDigiEvent
G__linked_taginfo G__RootEventData_rootcintLN_TDigiEvent
Definition: RootEventData_rootcint.cxx:34692
G__RootEventData_rootcintLN_TMdcDedx
G__linked_taginfo G__RootEventData_rootcintLN_TMdcDedx
Definition: RootEventData_rootcint.cxx:34720
G__cpp_setup_memfuncRootEventData_rootcint
void G__cpp_setup_memfuncRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:34539
G__RootEventData_rootcintLN_TEmcDigi
G__linked_taginfo G__RootEventData_rootcintLN_TEmcDigi
Definition: RootEventData_rootcint.cxx:34688
G__TTEvtRecTrack
TEvtRecTrack G__TTEvtRecTrack
Definition: RootEventData_rootcint.cxx:25667
G__TTRecMucTrack
TRecMucTrack G__TTRecMucTrack
Definition: RootEventData_rootcint.cxx:13895
G__RootEventData_rootcintLN_THltRaw
G__linked_taginfo G__RootEventData_rootcintLN_THltRaw
Definition: RootEventData_rootcint.cxx:34736
RootEventData_rootcint.h
G__Sizep2memfuncRootEventData_rootcint
Definition: RootEventData_rootcint.cxx:29076
G__Sizep2memfuncRootEventData_rootcint::sizep2memfunc
size_t sizep2memfunc()
Definition: RootEventData_rootcint.cxx:29079
G__Sizep2memfuncRootEventData_rootcint::G__Sizep2memfuncRootEventData_rootcint
G__Sizep2memfuncRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:29078
G__cpp_setup_initRootEventData_rootcint
Definition: RootEventData_rootcint.cxx:35025
G__cpp_setup_initRootEventData_rootcint::~G__cpp_setup_initRootEventData_rootcint
~G__cpp_setup_initRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:35028
G__cpp_setup_initRootEventData_rootcint::G__cpp_setup_initRootEventData_rootcint
G__cpp_setup_initRootEventData_rootcint()
Definition: RootEventData_rootcint.cxx:35027
TBossFullEvent::m_rectrackEvt
TRecTrackEvent * m_rectrackEvt
Definition: TBossFullEvent.h:118
TBossFullEvent::m_hltEvt
THltEvent * m_hltEvt
Definition: TBossFullEvent.h:117
TBossFullEvent::m_dstEvt
TDstEvent * m_dstEvt
Definition: TBossFullEvent.h:114
TBossFullEvent::m_evtRecObject
TEvtRecObject * m_evtRecObject
Definition: TBossFullEvent.h:119
TBossFullEvent::m_digiEvt
TDigiEvent * m_digiEvt
Definition: TBossFullEvent.h:113
TBossFullEvent::m_trigEvt
TTrigEvent * m_trigEvt
Definition: TBossFullEvent.h:116
TBossFullEvent::m_mcEvt
TMcEvent * m_mcEvt
Definition: TBossFullEvent.h:115
TBossFullEvent::m_EvtHeader
TEvtHeader * m_EvtHeader
Definition: TBossFullEvent.h:112
TEmcMc
Definition: TEmcMc.h:10
THltInf
Definition: THltInf.h:9
THltRaw
Definition: THltRaw.h:7
TMcParticle::PRIMARY
@ PRIMARY
Decayed in flight.
Definition: TMcParticle.h:91
TMcParticle::DECAYFLT
@ DECAYFLT
Decayed by generator.
Definition: TMcParticle.h:90
TMcParticle::ERROR
@ ERROR
this particle is a leaf in the particle tree
Definition: TMcParticle.h:93
TMcParticle::LEAF
@ LEAF
primary particle
Definition: TMcParticle.h:92
TMdcMc
Definition: TMdcMc.h:8
TMucMc
Definition: TMucMc.h:8
TRecZddChannel::Fragments
std::vector< std::pair< Int_t, Float_t > > Fragments
Definition: TRecZddChannel.h:15
TTofMc
Definition: TTofMc.h:8
y
double y[1000]
Definition: draw_charge_space_coarse_II.cxx:8
x
double x[1000]
Definition: draw_charge_space_coarse_II.cxx:8
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::GenerateInitInstance
TGenericClassInfo * GenerateInitInstance(const ::TJobInfo *)
Definition: RootEventData_rootcint.cxx:66
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
nhits
int nhits
Definition: prepare_data.cxx:29
charge
float charge
Definition: prepare_data.cxx:28