The Gaudi Framework  v29r5 (37229091)
GaudiKernelDict.cpp
Go to the documentation of this file.
1 // Do NOT change. Changes will be lost next time file is generated
2 
3 #define R__DICTIONARY_FILENAME GaudiKernelDict
4 
5 /*******************************************************************/
6 #include <stddef.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <assert.h>
11 #define G__DICTIONARY
12 #include "RConfig.h"
13 #include "TClass.h"
14 #include "TDictAttributeMap.h"
15 #include "TInterpreter.h"
16 #include "TROOT.h"
17 #include "TBuffer.h"
18 #include "TMemberInspector.h"
19 #include "TInterpreter.h"
20 #include "TVirtualMutex.h"
21 #include "TError.h"
22 
23 #ifndef G__ROOT
24 #define G__ROOT
25 #endif
26 
27 #include "RtypesImp.h"
28 #include "TIsAProxy.h"
29 #include "TFileMergeInfo.h"
30 #include <algorithm>
31 #include "TCollectionProxyInfo.h"
32 /*******************************************************************/
33 
34 #include "TDataMember.h"
35 
36 // Since CINT ignores the std namespace, we need to do so in this file.
37 namespace std {} using namespace std;
38 
39 // Header files passed as explicit arguments
40 #include "/builds/gaudi/Gaudi/GaudiKernel/dict/dictionary.h"
41 
42 // Header files passed via #pragma extra_include
43 
44 namespace ROOT {
45  static TClass *StatusCode_Dictionary();
46  static void StatusCode_TClassManip(TClass*);
47  static void *new_StatusCode(void *p = 0);
48  static void *newArray_StatusCode(Long_t size, void *p);
49  static void delete_StatusCode(void *p);
50  static void deleteArray_StatusCode(void *p);
51  static void destruct_StatusCode(void *p);
52 
53  // Function generating the singleton type initializer
54  static TGenericClassInfo *GenerateInitInstanceLocal(const ::StatusCode*)
55  {
56  ::StatusCode *ptr = 0;
57  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::StatusCode));
58  static ::ROOT::TGenericClassInfo
59  instance("StatusCode", "GaudiKernel/StatusCode.h", 26,
60  typeid(::StatusCode), ::ROOT::Internal::DefineBehavior(ptr, ptr),
61  &StatusCode_Dictionary, isa_proxy, 4,
62  sizeof(::StatusCode) );
63  instance.SetNew(&new_StatusCode);
64  instance.SetNewArray(&newArray_StatusCode);
65  instance.SetDelete(&delete_StatusCode);
66  instance.SetDeleteArray(&deleteArray_StatusCode);
67  instance.SetDestructor(&destruct_StatusCode);
68  return &instance;
69  }
70  TGenericClassInfo *GenerateInitInstance(const ::StatusCode*)
71  {
72  return GenerateInitInstanceLocal((::StatusCode*)0);
73  }
74  // Static variable to force the class initialization
75  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::StatusCode*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
76 
77  // Dictionary for non-ClassDef classes
78  static TClass *StatusCode_Dictionary() {
79  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::StatusCode*)0x0)->GetClass();
80  StatusCode_TClassManip(theClass);
81  return theClass;
82  }
83 
84  static void StatusCode_TClassManip(TClass* ){
85  }
86 
87 } // end of namespace ROOT
88 
89 namespace ROOT {
90  static TClass *InterfaceID_Dictionary();
91  static void InterfaceID_TClassManip(TClass*);
92  static void delete_InterfaceID(void *p);
93  static void deleteArray_InterfaceID(void *p);
94  static void destruct_InterfaceID(void *p);
95 
96  // Function generating the singleton type initializer
97  static TGenericClassInfo *GenerateInitInstanceLocal(const ::InterfaceID*)
98  {
99  ::InterfaceID *ptr = 0;
100  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::InterfaceID));
101  static ::ROOT::TGenericClassInfo
102  instance("InterfaceID", "GaudiKernel/IInterface.h", 29,
103  typeid(::InterfaceID), ::ROOT::Internal::DefineBehavior(ptr, ptr),
104  &InterfaceID_Dictionary, isa_proxy, 4,
105  sizeof(::InterfaceID) );
106  instance.SetDelete(&delete_InterfaceID);
107  instance.SetDeleteArray(&deleteArray_InterfaceID);
108  instance.SetDestructor(&destruct_InterfaceID);
109  return &instance;
110  }
111  TGenericClassInfo *GenerateInitInstance(const ::InterfaceID*)
112  {
113  return GenerateInitInstanceLocal((::InterfaceID*)0);
114  }
115  // Static variable to force the class initialization
116  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::InterfaceID*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
117 
118  // Dictionary for non-ClassDef classes
119  static TClass *InterfaceID_Dictionary() {
120  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::InterfaceID*)0x0)->GetClass();
121  InterfaceID_TClassManip(theClass);
122  return theClass;
123  }
124 
125  static void InterfaceID_TClassManip(TClass* ){
126  }
127 
128 } // end of namespace ROOT
129 
130 namespace ROOT {
131  static TClass *IInterface_Dictionary();
132  static void IInterface_TClassManip(TClass*);
133  static void delete_IInterface(void *p);
134  static void deleteArray_IInterface(void *p);
135  static void destruct_IInterface(void *p);
136 
137  // Function generating the singleton type initializer
138  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IInterface*)
139  {
140  ::IInterface *ptr = 0;
141  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IInterface));
142  static ::ROOT::TGenericClassInfo
143  instance("IInterface", "GaudiKernel/IInterface.h", 277,
144  typeid(::IInterface), ::ROOT::Internal::DefineBehavior(ptr, ptr),
145  &IInterface_Dictionary, isa_proxy, 4,
146  sizeof(::IInterface) );
147  instance.SetDelete(&delete_IInterface);
148  instance.SetDeleteArray(&deleteArray_IInterface);
149  instance.SetDestructor(&destruct_IInterface);
150  return &instance;
151  }
152  TGenericClassInfo *GenerateInitInstance(const ::IInterface*)
153  {
154  return GenerateInitInstanceLocal((::IInterface*)0);
155  }
156  // Static variable to force the class initialization
157  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IInterface*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
158 
159  // Dictionary for non-ClassDef classes
160  static TClass *IInterface_Dictionary() {
161  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IInterface*)0x0)->GetClass();
162  IInterface_TClassManip(theClass);
163  return theClass;
164  }
165 
166  static void IInterface_TClassManip(TClass* ){
167  }
168 
169 } // end of namespace ROOT
170 
171 namespace ROOT {
172  static TClass *IMessageSvc_Dictionary();
173  static void IMessageSvc_TClassManip(TClass*);
174  static void delete_IMessageSvc(void *p);
175  static void deleteArray_IMessageSvc(void *p);
176  static void destruct_IMessageSvc(void *p);
177 
178  // Function generating the singleton type initializer
179  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IMessageSvc*)
180  {
181  ::IMessageSvc *ptr = 0;
182  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IMessageSvc));
183  static ::ROOT::TGenericClassInfo
184  instance("IMessageSvc", "GaudiKernel/IMessageSvc.h", 38,
185  typeid(::IMessageSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
186  &IMessageSvc_Dictionary, isa_proxy, 4,
187  sizeof(::IMessageSvc) );
188  instance.SetDelete(&delete_IMessageSvc);
189  instance.SetDeleteArray(&deleteArray_IMessageSvc);
190  instance.SetDestructor(&destruct_IMessageSvc);
191  return &instance;
192  }
193  TGenericClassInfo *GenerateInitInstance(const ::IMessageSvc*)
194  {
195  return GenerateInitInstanceLocal((::IMessageSvc*)0);
196  }
197  // Static variable to force the class initialization
198  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IMessageSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
199 
200  // Dictionary for non-ClassDef classes
201  static TClass *IMessageSvc_Dictionary() {
202  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IMessageSvc*)0x0)->GetClass();
203  IMessageSvc_TClassManip(theClass);
204  return theClass;
205  }
206 
207  static void IMessageSvc_TClassManip(TClass* ){
208  }
209 
210 } // end of namespace ROOT
211 
212 namespace ROOT {
213  static TClass *INamedInterface_Dictionary();
214  static void INamedInterface_TClassManip(TClass*);
215  static void delete_INamedInterface(void *p);
216  static void deleteArray_INamedInterface(void *p);
217  static void destruct_INamedInterface(void *p);
218 
219  // Function generating the singleton type initializer
220  static TGenericClassInfo *GenerateInitInstanceLocal(const ::INamedInterface*)
221  {
222  ::INamedInterface *ptr = 0;
223  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::INamedInterface));
224  static ::ROOT::TGenericClassInfo
225  instance("INamedInterface", "GaudiKernel/INamedInterface.h", 15,
226  typeid(::INamedInterface), ::ROOT::Internal::DefineBehavior(ptr, ptr),
227  &INamedInterface_Dictionary, isa_proxy, 4,
228  sizeof(::INamedInterface) );
229  instance.SetDelete(&delete_INamedInterface);
230  instance.SetDeleteArray(&deleteArray_INamedInterface);
231  instance.SetDestructor(&destruct_INamedInterface);
232  return &instance;
233  }
234  TGenericClassInfo *GenerateInitInstance(const ::INamedInterface*)
235  {
236  return GenerateInitInstanceLocal((::INamedInterface*)0);
237  }
238  // Static variable to force the class initialization
239  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::INamedInterface*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
240 
241  // Dictionary for non-ClassDef classes
242  static TClass *INamedInterface_Dictionary() {
243  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::INamedInterface*)0x0)->GetClass();
244  INamedInterface_TClassManip(theClass);
245  return theClass;
246  }
247 
248  static void INamedInterface_TClassManip(TClass* ){
249  }
250 
251 } // end of namespace ROOT
252 
253 namespace ROOT {
254  static TClass *IStateful_Dictionary();
255  static void IStateful_TClassManip(TClass*);
256  static void delete_IStateful(void *p);
257  static void deleteArray_IStateful(void *p);
258  static void destruct_IStateful(void *p);
259 
260  // Function generating the singleton type initializer
261  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IStateful*)
262  {
263  ::IStateful *ptr = 0;
264  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IStateful));
265  static ::ROOT::TGenericClassInfo
266  instance("IStateful", "GaudiKernel/IStateful.h", 16,
267  typeid(::IStateful), ::ROOT::Internal::DefineBehavior(ptr, ptr),
268  &IStateful_Dictionary, isa_proxy, 4,
269  sizeof(::IStateful) );
270  instance.SetDelete(&delete_IStateful);
271  instance.SetDeleteArray(&deleteArray_IStateful);
272  instance.SetDestructor(&destruct_IStateful);
273  return &instance;
274  }
275  TGenericClassInfo *GenerateInitInstance(const ::IStateful*)
276  {
277  return GenerateInitInstanceLocal((::IStateful*)0);
278  }
279  // Static variable to force the class initialization
280  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IStateful*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
281 
282  // Dictionary for non-ClassDef classes
283  static TClass *IStateful_Dictionary() {
284  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IStateful*)0x0)->GetClass();
285  IStateful_TClassManip(theClass);
286  return theClass;
287  }
288 
289  static void IStateful_TClassManip(TClass* ){
290  }
291 
292 } // end of namespace ROOT
293 
294 namespace ROOT {
295  static TClass *IService_Dictionary();
296  static void IService_TClassManip(TClass*);
297  static void delete_IService(void *p);
298  static void deleteArray_IService(void *p);
299  static void destruct_IService(void *p);
300 
301  // Function generating the singleton type initializer
302  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IService*)
303  {
304  ::IService *ptr = 0;
305  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IService));
306  static ::ROOT::TGenericClassInfo
307  instance("IService", "GaudiKernel/IService.h", 18,
308  typeid(::IService), ::ROOT::Internal::DefineBehavior(ptr, ptr),
309  &IService_Dictionary, isa_proxy, 4,
310  sizeof(::IService) );
311  instance.SetDelete(&delete_IService);
312  instance.SetDeleteArray(&deleteArray_IService);
313  instance.SetDestructor(&destruct_IService);
314  return &instance;
315  }
316  TGenericClassInfo *GenerateInitInstance(const ::IService*)
317  {
318  return GenerateInitInstanceLocal((::IService*)0);
319  }
320  // Static variable to force the class initialization
321  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IService*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
322 
323  // Dictionary for non-ClassDef classes
324  static TClass *IService_Dictionary() {
325  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IService*)0x0)->GetClass();
326  IService_TClassManip(theClass);
327  return theClass;
328  }
329 
330  static void IService_TClassManip(TClass* ){
331  }
332 
333 } // end of namespace ROOT
334 
335 namespace ROOT {
336  static TClass *SmartIFlEIPropertygR_Dictionary();
337  static void SmartIFlEIPropertygR_TClassManip(TClass*);
338  static void *new_SmartIFlEIPropertygR(void *p = 0);
339  static void *newArray_SmartIFlEIPropertygR(Long_t size, void *p);
340  static void delete_SmartIFlEIPropertygR(void *p);
341  static void deleteArray_SmartIFlEIPropertygR(void *p);
342  static void destruct_SmartIFlEIPropertygR(void *p);
343 
344  // Function generating the singleton type initializer
345  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IProperty>*)
346  {
347  ::SmartIF<IProperty> *ptr = 0;
348  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IProperty>));
349  static ::ROOT::TGenericClassInfo
350  instance("SmartIF<IProperty>", "GaudiKernel/SmartIF.h", 19,
351  typeid(::SmartIF<IProperty>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
352  &SmartIFlEIPropertygR_Dictionary, isa_proxy, 4,
353  sizeof(::SmartIF<IProperty>) );
354  instance.SetNew(&new_SmartIFlEIPropertygR);
355  instance.SetNewArray(&newArray_SmartIFlEIPropertygR);
356  instance.SetDelete(&delete_SmartIFlEIPropertygR);
357  instance.SetDeleteArray(&deleteArray_SmartIFlEIPropertygR);
358  instance.SetDestructor(&destruct_SmartIFlEIPropertygR);
359  return &instance;
360  }
361  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IProperty>*)
362  {
363  return GenerateInitInstanceLocal((::SmartIF<IProperty>*)0);
364  }
365  // Static variable to force the class initialization
366  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IProperty>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
367 
368  // Dictionary for non-ClassDef classes
369  static TClass *SmartIFlEIPropertygR_Dictionary() {
370  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IProperty>*)0x0)->GetClass();
371  SmartIFlEIPropertygR_TClassManip(theClass);
372  return theClass;
373  }
374 
375  static void SmartIFlEIPropertygR_TClassManip(TClass* ){
376  }
377 
378 } // end of namespace ROOT
379 
380 namespace ROOT {
381  static TClass *SmartIFlEIServicegR_Dictionary();
382  static void SmartIFlEIServicegR_TClassManip(TClass*);
383  static void *new_SmartIFlEIServicegR(void *p = 0);
384  static void *newArray_SmartIFlEIServicegR(Long_t size, void *p);
385  static void delete_SmartIFlEIServicegR(void *p);
386  static void deleteArray_SmartIFlEIServicegR(void *p);
387  static void destruct_SmartIFlEIServicegR(void *p);
388 
389  // Function generating the singleton type initializer
390  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IService>*)
391  {
392  ::SmartIF<IService> *ptr = 0;
393  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IService>));
394  static ::ROOT::TGenericClassInfo
395  instance("SmartIF<IService>", "GaudiKernel/SmartIF.h", 19,
396  typeid(::SmartIF<IService>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
397  &SmartIFlEIServicegR_Dictionary, isa_proxy, 4,
398  sizeof(::SmartIF<IService>) );
399  instance.SetNew(&new_SmartIFlEIServicegR);
400  instance.SetNewArray(&newArray_SmartIFlEIServicegR);
401  instance.SetDelete(&delete_SmartIFlEIServicegR);
402  instance.SetDeleteArray(&deleteArray_SmartIFlEIServicegR);
403  instance.SetDestructor(&destruct_SmartIFlEIServicegR);
404  return &instance;
405  }
406  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IService>*)
407  {
408  return GenerateInitInstanceLocal((::SmartIF<IService>*)0);
409  }
410  // Static variable to force the class initialization
411  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IService>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
412 
413  // Dictionary for non-ClassDef classes
414  static TClass *SmartIFlEIServicegR_Dictionary() {
415  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IService>*)0x0)->GetClass();
416  SmartIFlEIServicegR_TClassManip(theClass);
417  return theClass;
418  }
419 
420  static void SmartIFlEIServicegR_TClassManip(TClass* ){
421  }
422 
423 } // end of namespace ROOT
424 
425 namespace ROOT {
426  static TClass *SmartIFlEISvcLocatorgR_Dictionary();
427  static void SmartIFlEISvcLocatorgR_TClassManip(TClass*);
428  static void *new_SmartIFlEISvcLocatorgR(void *p = 0);
429  static void *newArray_SmartIFlEISvcLocatorgR(Long_t size, void *p);
430  static void delete_SmartIFlEISvcLocatorgR(void *p);
431  static void deleteArray_SmartIFlEISvcLocatorgR(void *p);
432  static void destruct_SmartIFlEISvcLocatorgR(void *p);
433 
434  // Function generating the singleton type initializer
435  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<ISvcLocator>*)
436  {
437  ::SmartIF<ISvcLocator> *ptr = 0;
438  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<ISvcLocator>));
439  static ::ROOT::TGenericClassInfo
440  instance("SmartIF<ISvcLocator>", "GaudiKernel/SmartIF.h", 19,
441  typeid(::SmartIF<ISvcLocator>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
442  &SmartIFlEISvcLocatorgR_Dictionary, isa_proxy, 4,
443  sizeof(::SmartIF<ISvcLocator>) );
444  instance.SetNew(&new_SmartIFlEISvcLocatorgR);
445  instance.SetNewArray(&newArray_SmartIFlEISvcLocatorgR);
446  instance.SetDelete(&delete_SmartIFlEISvcLocatorgR);
447  instance.SetDeleteArray(&deleteArray_SmartIFlEISvcLocatorgR);
448  instance.SetDestructor(&destruct_SmartIFlEISvcLocatorgR);
449  return &instance;
450  }
451  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<ISvcLocator>*)
452  {
453  return GenerateInitInstanceLocal((::SmartIF<ISvcLocator>*)0);
454  }
455  // Static variable to force the class initialization
456  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<ISvcLocator>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
457 
458  // Dictionary for non-ClassDef classes
459  static TClass *SmartIFlEISvcLocatorgR_Dictionary() {
460  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<ISvcLocator>*)0x0)->GetClass();
461  SmartIFlEISvcLocatorgR_TClassManip(theClass);
462  return theClass;
463  }
464 
465  static void SmartIFlEISvcLocatorgR_TClassManip(TClass* ){
466  }
467 
468 } // end of namespace ROOT
469 
470 namespace ROOT {
471  static TClass *SmartIFlEIMessageSvcgR_Dictionary();
472  static void SmartIFlEIMessageSvcgR_TClassManip(TClass*);
473  static void *new_SmartIFlEIMessageSvcgR(void *p = 0);
474  static void *newArray_SmartIFlEIMessageSvcgR(Long_t size, void *p);
475  static void delete_SmartIFlEIMessageSvcgR(void *p);
476  static void deleteArray_SmartIFlEIMessageSvcgR(void *p);
477  static void destruct_SmartIFlEIMessageSvcgR(void *p);
478 
479  // Function generating the singleton type initializer
480  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IMessageSvc>*)
481  {
482  ::SmartIF<IMessageSvc> *ptr = 0;
483  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IMessageSvc>));
484  static ::ROOT::TGenericClassInfo
485  instance("SmartIF<IMessageSvc>", "GaudiKernel/SmartIF.h", 19,
486  typeid(::SmartIF<IMessageSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
487  &SmartIFlEIMessageSvcgR_Dictionary, isa_proxy, 4,
488  sizeof(::SmartIF<IMessageSvc>) );
489  instance.SetNew(&new_SmartIFlEIMessageSvcgR);
490  instance.SetNewArray(&newArray_SmartIFlEIMessageSvcgR);
491  instance.SetDelete(&delete_SmartIFlEIMessageSvcgR);
492  instance.SetDeleteArray(&deleteArray_SmartIFlEIMessageSvcgR);
493  instance.SetDestructor(&destruct_SmartIFlEIMessageSvcgR);
494  return &instance;
495  }
496  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IMessageSvc>*)
497  {
498  return GenerateInitInstanceLocal((::SmartIF<IMessageSvc>*)0);
499  }
500  // Static variable to force the class initialization
501  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IMessageSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
502 
503  // Dictionary for non-ClassDef classes
504  static TClass *SmartIFlEIMessageSvcgR_Dictionary() {
505  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IMessageSvc>*)0x0)->GetClass();
506  SmartIFlEIMessageSvcgR_TClassManip(theClass);
507  return theClass;
508  }
509 
510  static void SmartIFlEIMessageSvcgR_TClassManip(TClass* ){
511  }
512 
513 } // end of namespace ROOT
514 
515 namespace ROOT {
516  static TClass *SmartIFlEIDataProviderSvcgR_Dictionary();
517  static void SmartIFlEIDataProviderSvcgR_TClassManip(TClass*);
518  static void *new_SmartIFlEIDataProviderSvcgR(void *p = 0);
519  static void *newArray_SmartIFlEIDataProviderSvcgR(Long_t size, void *p);
520  static void delete_SmartIFlEIDataProviderSvcgR(void *p);
521  static void deleteArray_SmartIFlEIDataProviderSvcgR(void *p);
522  static void destruct_SmartIFlEIDataProviderSvcgR(void *p);
523 
524  // Function generating the singleton type initializer
525  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IDataProviderSvc>*)
526  {
527  ::SmartIF<IDataProviderSvc> *ptr = 0;
528  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IDataProviderSvc>));
529  static ::ROOT::TGenericClassInfo
530  instance("SmartIF<IDataProviderSvc>", "GaudiKernel/SmartIF.h", 19,
531  typeid(::SmartIF<IDataProviderSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
532  &SmartIFlEIDataProviderSvcgR_Dictionary, isa_proxy, 4,
533  sizeof(::SmartIF<IDataProviderSvc>) );
534  instance.SetNew(&new_SmartIFlEIDataProviderSvcgR);
535  instance.SetNewArray(&newArray_SmartIFlEIDataProviderSvcgR);
536  instance.SetDelete(&delete_SmartIFlEIDataProviderSvcgR);
537  instance.SetDeleteArray(&deleteArray_SmartIFlEIDataProviderSvcgR);
538  instance.SetDestructor(&destruct_SmartIFlEIDataProviderSvcgR);
539  return &instance;
540  }
541  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IDataProviderSvc>*)
542  {
543  return GenerateInitInstanceLocal((::SmartIF<IDataProviderSvc>*)0);
544  }
545  // Static variable to force the class initialization
546  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IDataProviderSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
547 
548  // Dictionary for non-ClassDef classes
549  static TClass *SmartIFlEIDataProviderSvcgR_Dictionary() {
550  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IDataProviderSvc>*)0x0)->GetClass();
551  SmartIFlEIDataProviderSvcgR_TClassManip(theClass);
552  return theClass;
553  }
554 
555  static void SmartIFlEIDataProviderSvcgR_TClassManip(TClass* ){
556  }
557 
558 } // end of namespace ROOT
559 
560 namespace ROOT {
561  static TClass *SmartIFlEIToolSvcgR_Dictionary();
562  static void SmartIFlEIToolSvcgR_TClassManip(TClass*);
563  static void *new_SmartIFlEIToolSvcgR(void *p = 0);
564  static void *newArray_SmartIFlEIToolSvcgR(Long_t size, void *p);
565  static void delete_SmartIFlEIToolSvcgR(void *p);
566  static void deleteArray_SmartIFlEIToolSvcgR(void *p);
567  static void destruct_SmartIFlEIToolSvcgR(void *p);
568 
569  // Function generating the singleton type initializer
570  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IToolSvc>*)
571  {
572  ::SmartIF<IToolSvc> *ptr = 0;
573  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IToolSvc>));
574  static ::ROOT::TGenericClassInfo
575  instance("SmartIF<IToolSvc>", "GaudiKernel/SmartIF.h", 19,
576  typeid(::SmartIF<IToolSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
577  &SmartIFlEIToolSvcgR_Dictionary, isa_proxy, 4,
578  sizeof(::SmartIF<IToolSvc>) );
579  instance.SetNew(&new_SmartIFlEIToolSvcgR);
580  instance.SetNewArray(&newArray_SmartIFlEIToolSvcgR);
581  instance.SetDelete(&delete_SmartIFlEIToolSvcgR);
582  instance.SetDeleteArray(&deleteArray_SmartIFlEIToolSvcgR);
583  instance.SetDestructor(&destruct_SmartIFlEIToolSvcgR);
584  return &instance;
585  }
586  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IToolSvc>*)
587  {
588  return GenerateInitInstanceLocal((::SmartIF<IToolSvc>*)0);
589  }
590  // Static variable to force the class initialization
591  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IToolSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
592 
593  // Dictionary for non-ClassDef classes
594  static TClass *SmartIFlEIToolSvcgR_Dictionary() {
595  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IToolSvc>*)0x0)->GetClass();
596  SmartIFlEIToolSvcgR_TClassManip(theClass);
597  return theClass;
598  }
599 
600  static void SmartIFlEIToolSvcgR_TClassManip(TClass* ){
601  }
602 
603 } // end of namespace ROOT
604 
605 namespace ROOT {
606  static TClass *SmartIFlEIMonitorSvcgR_Dictionary();
607  static void SmartIFlEIMonitorSvcgR_TClassManip(TClass*);
608  static void *new_SmartIFlEIMonitorSvcgR(void *p = 0);
609  static void *newArray_SmartIFlEIMonitorSvcgR(Long_t size, void *p);
610  static void delete_SmartIFlEIMonitorSvcgR(void *p);
611  static void deleteArray_SmartIFlEIMonitorSvcgR(void *p);
612  static void destruct_SmartIFlEIMonitorSvcgR(void *p);
613 
614  // Function generating the singleton type initializer
615  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IMonitorSvc>*)
616  {
617  ::SmartIF<IMonitorSvc> *ptr = 0;
618  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IMonitorSvc>));
619  static ::ROOT::TGenericClassInfo
620  instance("SmartIF<IMonitorSvc>", "GaudiKernel/SmartIF.h", 19,
621  typeid(::SmartIF<IMonitorSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
622  &SmartIFlEIMonitorSvcgR_Dictionary, isa_proxy, 4,
623  sizeof(::SmartIF<IMonitorSvc>) );
624  instance.SetNew(&new_SmartIFlEIMonitorSvcgR);
625  instance.SetNewArray(&newArray_SmartIFlEIMonitorSvcgR);
626  instance.SetDelete(&delete_SmartIFlEIMonitorSvcgR);
627  instance.SetDeleteArray(&deleteArray_SmartIFlEIMonitorSvcgR);
628  instance.SetDestructor(&destruct_SmartIFlEIMonitorSvcgR);
629  return &instance;
630  }
631  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IMonitorSvc>*)
632  {
633  return GenerateInitInstanceLocal((::SmartIF<IMonitorSvc>*)0);
634  }
635  // Static variable to force the class initialization
636  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IMonitorSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
637 
638  // Dictionary for non-ClassDef classes
639  static TClass *SmartIFlEIMonitorSvcgR_Dictionary() {
640  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IMonitorSvc>*)0x0)->GetClass();
641  SmartIFlEIMonitorSvcgR_TClassManip(theClass);
642  return theClass;
643  }
644 
645  static void SmartIFlEIMonitorSvcgR_TClassManip(TClass* ){
646  }
647 
648 } // end of namespace ROOT
649 
650 namespace ROOT {
651  static TClass *SmartIFlEIAuditorSvcgR_Dictionary();
652  static void SmartIFlEIAuditorSvcgR_TClassManip(TClass*);
653  static void *new_SmartIFlEIAuditorSvcgR(void *p = 0);
654  static void *newArray_SmartIFlEIAuditorSvcgR(Long_t size, void *p);
655  static void delete_SmartIFlEIAuditorSvcgR(void *p);
656  static void deleteArray_SmartIFlEIAuditorSvcgR(void *p);
657  static void destruct_SmartIFlEIAuditorSvcgR(void *p);
658 
659  // Function generating the singleton type initializer
660  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IAuditorSvc>*)
661  {
662  ::SmartIF<IAuditorSvc> *ptr = 0;
663  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IAuditorSvc>));
664  static ::ROOT::TGenericClassInfo
665  instance("SmartIF<IAuditorSvc>", "GaudiKernel/SmartIF.h", 19,
666  typeid(::SmartIF<IAuditorSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
667  &SmartIFlEIAuditorSvcgR_Dictionary, isa_proxy, 4,
668  sizeof(::SmartIF<IAuditorSvc>) );
669  instance.SetNew(&new_SmartIFlEIAuditorSvcgR);
670  instance.SetNewArray(&newArray_SmartIFlEIAuditorSvcgR);
671  instance.SetDelete(&delete_SmartIFlEIAuditorSvcgR);
672  instance.SetDeleteArray(&deleteArray_SmartIFlEIAuditorSvcgR);
673  instance.SetDestructor(&destruct_SmartIFlEIAuditorSvcgR);
674  return &instance;
675  }
676  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IAuditorSvc>*)
677  {
678  return GenerateInitInstanceLocal((::SmartIF<IAuditorSvc>*)0);
679  }
680  // Static variable to force the class initialization
681  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IAuditorSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
682 
683  // Dictionary for non-ClassDef classes
684  static TClass *SmartIFlEIAuditorSvcgR_Dictionary() {
685  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IAuditorSvc>*)0x0)->GetClass();
686  SmartIFlEIAuditorSvcgR_TClassManip(theClass);
687  return theClass;
688  }
689 
690  static void SmartIFlEIAuditorSvcgR_TClassManip(TClass* ){
691  }
692 
693 } // end of namespace ROOT
694 
695 namespace ROOT {
696  static TClass *SmartIFlEIAlgContextSvcgR_Dictionary();
697  static void SmartIFlEIAlgContextSvcgR_TClassManip(TClass*);
698  static void *new_SmartIFlEIAlgContextSvcgR(void *p = 0);
699  static void *newArray_SmartIFlEIAlgContextSvcgR(Long_t size, void *p);
700  static void delete_SmartIFlEIAlgContextSvcgR(void *p);
701  static void deleteArray_SmartIFlEIAlgContextSvcgR(void *p);
702  static void destruct_SmartIFlEIAlgContextSvcgR(void *p);
703 
704  // Function generating the singleton type initializer
705  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IAlgContextSvc>*)
706  {
707  ::SmartIF<IAlgContextSvc> *ptr = 0;
708  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IAlgContextSvc>));
709  static ::ROOT::TGenericClassInfo
710  instance("SmartIF<IAlgContextSvc>", "GaudiKernel/SmartIF.h", 19,
711  typeid(::SmartIF<IAlgContextSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
712  &SmartIFlEIAlgContextSvcgR_Dictionary, isa_proxy, 4,
713  sizeof(::SmartIF<IAlgContextSvc>) );
714  instance.SetNew(&new_SmartIFlEIAlgContextSvcgR);
715  instance.SetNewArray(&newArray_SmartIFlEIAlgContextSvcgR);
716  instance.SetDelete(&delete_SmartIFlEIAlgContextSvcgR);
717  instance.SetDeleteArray(&deleteArray_SmartIFlEIAlgContextSvcgR);
718  instance.SetDestructor(&destruct_SmartIFlEIAlgContextSvcgR);
719  return &instance;
720  }
721  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IAlgContextSvc>*)
722  {
723  return GenerateInitInstanceLocal((::SmartIF<IAlgContextSvc>*)0);
724  }
725  // Static variable to force the class initialization
726  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IAlgContextSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
727 
728  // Dictionary for non-ClassDef classes
729  static TClass *SmartIFlEIAlgContextSvcgR_Dictionary() {
730  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IAlgContextSvc>*)0x0)->GetClass();
731  SmartIFlEIAlgContextSvcgR_TClassManip(theClass);
732  return theClass;
733  }
734 
735  static void SmartIFlEIAlgContextSvcgR_TClassManip(TClass* ){
736  }
737 
738 } // end of namespace ROOT
739 
740 namespace ROOT {
741  static TClass *SmartIFlEIAlgorithmgR_Dictionary();
742  static void SmartIFlEIAlgorithmgR_TClassManip(TClass*);
743  static void *new_SmartIFlEIAlgorithmgR(void *p = 0);
744  static void *newArray_SmartIFlEIAlgorithmgR(Long_t size, void *p);
745  static void delete_SmartIFlEIAlgorithmgR(void *p);
746  static void deleteArray_SmartIFlEIAlgorithmgR(void *p);
747  static void destruct_SmartIFlEIAlgorithmgR(void *p);
748 
749  // Function generating the singleton type initializer
750  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IAlgorithm>*)
751  {
752  ::SmartIF<IAlgorithm> *ptr = 0;
753  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IAlgorithm>));
754  static ::ROOT::TGenericClassInfo
755  instance("SmartIF<IAlgorithm>", "GaudiKernel/SmartIF.h", 19,
756  typeid(::SmartIF<IAlgorithm>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
757  &SmartIFlEIAlgorithmgR_Dictionary, isa_proxy, 4,
758  sizeof(::SmartIF<IAlgorithm>) );
759  instance.SetNew(&new_SmartIFlEIAlgorithmgR);
760  instance.SetNewArray(&newArray_SmartIFlEIAlgorithmgR);
761  instance.SetDelete(&delete_SmartIFlEIAlgorithmgR);
762  instance.SetDeleteArray(&deleteArray_SmartIFlEIAlgorithmgR);
763  instance.SetDestructor(&destruct_SmartIFlEIAlgorithmgR);
764  return &instance;
765  }
766  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IAlgorithm>*)
767  {
768  return GenerateInitInstanceLocal((::SmartIF<IAlgorithm>*)0);
769  }
770  // Static variable to force the class initialization
771  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IAlgorithm>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
772 
773  // Dictionary for non-ClassDef classes
774  static TClass *SmartIFlEIAlgorithmgR_Dictionary() {
775  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IAlgorithm>*)0x0)->GetClass();
776  SmartIFlEIAlgorithmgR_TClassManip(theClass);
777  return theClass;
778  }
779 
780  static void SmartIFlEIAlgorithmgR_TClassManip(TClass* ){
781  }
782 
783 } // end of namespace ROOT
784 
785 namespace ROOT {
786  static TClass *SmartIFlEIConversionSvcgR_Dictionary();
787  static void SmartIFlEIConversionSvcgR_TClassManip(TClass*);
788  static void *new_SmartIFlEIConversionSvcgR(void *p = 0);
789  static void *newArray_SmartIFlEIConversionSvcgR(Long_t size, void *p);
790  static void delete_SmartIFlEIConversionSvcgR(void *p);
791  static void deleteArray_SmartIFlEIConversionSvcgR(void *p);
792  static void destruct_SmartIFlEIConversionSvcgR(void *p);
793 
794  // Function generating the singleton type initializer
795  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IConversionSvc>*)
796  {
797  ::SmartIF<IConversionSvc> *ptr = 0;
798  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IConversionSvc>));
799  static ::ROOT::TGenericClassInfo
800  instance("SmartIF<IConversionSvc>", "GaudiKernel/SmartIF.h", 19,
801  typeid(::SmartIF<IConversionSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
802  &SmartIFlEIConversionSvcgR_Dictionary, isa_proxy, 4,
803  sizeof(::SmartIF<IConversionSvc>) );
804  instance.SetNew(&new_SmartIFlEIConversionSvcgR);
805  instance.SetNewArray(&newArray_SmartIFlEIConversionSvcgR);
806  instance.SetDelete(&delete_SmartIFlEIConversionSvcgR);
807  instance.SetDeleteArray(&deleteArray_SmartIFlEIConversionSvcgR);
808  instance.SetDestructor(&destruct_SmartIFlEIConversionSvcgR);
809  return &instance;
810  }
811  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IConversionSvc>*)
812  {
813  return GenerateInitInstanceLocal((::SmartIF<IConversionSvc>*)0);
814  }
815  // Static variable to force the class initialization
816  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IConversionSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
817 
818  // Dictionary for non-ClassDef classes
819  static TClass *SmartIFlEIConversionSvcgR_Dictionary() {
820  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IConversionSvc>*)0x0)->GetClass();
821  SmartIFlEIConversionSvcgR_TClassManip(theClass);
822  return theClass;
823  }
824 
825  static void SmartIFlEIConversionSvcgR_TClassManip(TClass* ){
826  }
827 
828 } // end of namespace ROOT
829 
830 namespace ROOT {
831  static TClass *SmartIFlEIRndmGengR_Dictionary();
832  static void SmartIFlEIRndmGengR_TClassManip(TClass*);
833  static void *new_SmartIFlEIRndmGengR(void *p = 0);
834  static void *newArray_SmartIFlEIRndmGengR(Long_t size, void *p);
835  static void delete_SmartIFlEIRndmGengR(void *p);
836  static void deleteArray_SmartIFlEIRndmGengR(void *p);
837  static void destruct_SmartIFlEIRndmGengR(void *p);
838 
839  // Function generating the singleton type initializer
840  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IRndmGen>*)
841  {
842  ::SmartIF<IRndmGen> *ptr = 0;
843  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IRndmGen>));
844  static ::ROOT::TGenericClassInfo
845  instance("SmartIF<IRndmGen>", "GaudiKernel/SmartIF.h", 19,
846  typeid(::SmartIF<IRndmGen>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
847  &SmartIFlEIRndmGengR_Dictionary, isa_proxy, 4,
848  sizeof(::SmartIF<IRndmGen>) );
849  instance.SetNew(&new_SmartIFlEIRndmGengR);
850  instance.SetNewArray(&newArray_SmartIFlEIRndmGengR);
851  instance.SetDelete(&delete_SmartIFlEIRndmGengR);
852  instance.SetDeleteArray(&deleteArray_SmartIFlEIRndmGengR);
853  instance.SetDestructor(&destruct_SmartIFlEIRndmGengR);
854  return &instance;
855  }
856  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IRndmGen>*)
857  {
858  return GenerateInitInstanceLocal((::SmartIF<IRndmGen>*)0);
859  }
860  // Static variable to force the class initialization
861  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IRndmGen>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
862 
863  // Dictionary for non-ClassDef classes
864  static TClass *SmartIFlEIRndmGengR_Dictionary() {
865  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IRndmGen>*)0x0)->GetClass();
866  SmartIFlEIRndmGengR_TClassManip(theClass);
867  return theClass;
868  }
869 
870  static void SmartIFlEIRndmGengR_TClassManip(TClass* ){
871  }
872 
873 } // end of namespace ROOT
874 
875 namespace ROOT {
876  static TClass *SmartIFlEIChronoStatSvcgR_Dictionary();
877  static void SmartIFlEIChronoStatSvcgR_TClassManip(TClass*);
878  static void *new_SmartIFlEIChronoStatSvcgR(void *p = 0);
879  static void *newArray_SmartIFlEIChronoStatSvcgR(Long_t size, void *p);
880  static void delete_SmartIFlEIChronoStatSvcgR(void *p);
881  static void deleteArray_SmartIFlEIChronoStatSvcgR(void *p);
882  static void destruct_SmartIFlEIChronoStatSvcgR(void *p);
883 
884  // Function generating the singleton type initializer
885  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IChronoStatSvc>*)
886  {
887  ::SmartIF<IChronoStatSvc> *ptr = 0;
888  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IChronoStatSvc>));
889  static ::ROOT::TGenericClassInfo
890  instance("SmartIF<IChronoStatSvc>", "GaudiKernel/SmartIF.h", 19,
891  typeid(::SmartIF<IChronoStatSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
892  &SmartIFlEIChronoStatSvcgR_Dictionary, isa_proxy, 4,
893  sizeof(::SmartIF<IChronoStatSvc>) );
894  instance.SetNew(&new_SmartIFlEIChronoStatSvcgR);
895  instance.SetNewArray(&newArray_SmartIFlEIChronoStatSvcgR);
896  instance.SetDelete(&delete_SmartIFlEIChronoStatSvcgR);
897  instance.SetDeleteArray(&deleteArray_SmartIFlEIChronoStatSvcgR);
898  instance.SetDestructor(&destruct_SmartIFlEIChronoStatSvcgR);
899  return &instance;
900  }
901  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IChronoStatSvc>*)
902  {
903  return GenerateInitInstanceLocal((::SmartIF<IChronoStatSvc>*)0);
904  }
905  // Static variable to force the class initialization
906  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IChronoStatSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
907 
908  // Dictionary for non-ClassDef classes
909  static TClass *SmartIFlEIChronoStatSvcgR_Dictionary() {
910  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IChronoStatSvc>*)0x0)->GetClass();
911  SmartIFlEIChronoStatSvcgR_TClassManip(theClass);
912  return theClass;
913  }
914 
915  static void SmartIFlEIChronoStatSvcgR_TClassManip(TClass* ){
916  }
917 
918 } // end of namespace ROOT
919 
920 namespace ROOT {
921  static TClass *SmartIFlEIHistogramSvcgR_Dictionary();
922  static void SmartIFlEIHistogramSvcgR_TClassManip(TClass*);
923  static void *new_SmartIFlEIHistogramSvcgR(void *p = 0);
924  static void *newArray_SmartIFlEIHistogramSvcgR(Long_t size, void *p);
925  static void delete_SmartIFlEIHistogramSvcgR(void *p);
926  static void deleteArray_SmartIFlEIHistogramSvcgR(void *p);
927  static void destruct_SmartIFlEIHistogramSvcgR(void *p);
928 
929  // Function generating the singleton type initializer
930  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IHistogramSvc>*)
931  {
932  ::SmartIF<IHistogramSvc> *ptr = 0;
933  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IHistogramSvc>));
934  static ::ROOT::TGenericClassInfo
935  instance("SmartIF<IHistogramSvc>", "GaudiKernel/SmartIF.h", 19,
936  typeid(::SmartIF<IHistogramSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
937  &SmartIFlEIHistogramSvcgR_Dictionary, isa_proxy, 4,
938  sizeof(::SmartIF<IHistogramSvc>) );
939  instance.SetNew(&new_SmartIFlEIHistogramSvcgR);
940  instance.SetNewArray(&newArray_SmartIFlEIHistogramSvcgR);
941  instance.SetDelete(&delete_SmartIFlEIHistogramSvcgR);
942  instance.SetDeleteArray(&deleteArray_SmartIFlEIHistogramSvcgR);
943  instance.SetDestructor(&destruct_SmartIFlEIHistogramSvcgR);
944  return &instance;
945  }
946  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IHistogramSvc>*)
947  {
948  return GenerateInitInstanceLocal((::SmartIF<IHistogramSvc>*)0);
949  }
950  // Static variable to force the class initialization
951  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IHistogramSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
952 
953  // Dictionary for non-ClassDef classes
954  static TClass *SmartIFlEIHistogramSvcgR_Dictionary() {
955  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IHistogramSvc>*)0x0)->GetClass();
956  SmartIFlEIHistogramSvcgR_TClassManip(theClass);
957  return theClass;
958  }
959 
960  static void SmartIFlEIHistogramSvcgR_TClassManip(TClass* ){
961  }
962 
963 } // end of namespace ROOT
964 
965 namespace ROOT {
966  static TClass *SmartIFlEINTupleSvcgR_Dictionary();
967  static void SmartIFlEINTupleSvcgR_TClassManip(TClass*);
968  static void *new_SmartIFlEINTupleSvcgR(void *p = 0);
969  static void *newArray_SmartIFlEINTupleSvcgR(Long_t size, void *p);
970  static void delete_SmartIFlEINTupleSvcgR(void *p);
971  static void deleteArray_SmartIFlEINTupleSvcgR(void *p);
972  static void destruct_SmartIFlEINTupleSvcgR(void *p);
973 
974  // Function generating the singleton type initializer
975  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<INTupleSvc>*)
976  {
977  ::SmartIF<INTupleSvc> *ptr = 0;
978  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<INTupleSvc>));
979  static ::ROOT::TGenericClassInfo
980  instance("SmartIF<INTupleSvc>", "GaudiKernel/SmartIF.h", 19,
981  typeid(::SmartIF<INTupleSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
982  &SmartIFlEINTupleSvcgR_Dictionary, isa_proxy, 4,
983  sizeof(::SmartIF<INTupleSvc>) );
984  instance.SetNew(&new_SmartIFlEINTupleSvcgR);
985  instance.SetNewArray(&newArray_SmartIFlEINTupleSvcgR);
986  instance.SetDelete(&delete_SmartIFlEINTupleSvcgR);
987  instance.SetDeleteArray(&deleteArray_SmartIFlEINTupleSvcgR);
988  instance.SetDestructor(&destruct_SmartIFlEINTupleSvcgR);
989  return &instance;
990  }
991  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<INTupleSvc>*)
992  {
993  return GenerateInitInstanceLocal((::SmartIF<INTupleSvc>*)0);
994  }
995  // Static variable to force the class initialization
996  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<INTupleSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
997 
998  // Dictionary for non-ClassDef classes
999  static TClass *SmartIFlEINTupleSvcgR_Dictionary() {
1000  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<INTupleSvc>*)0x0)->GetClass();
1001  SmartIFlEINTupleSvcgR_TClassManip(theClass);
1002  return theClass;
1003  }
1004 
1005  static void SmartIFlEINTupleSvcgR_TClassManip(TClass* ){
1006  }
1007 
1008 } // end of namespace ROOT
1009 
1010 namespace ROOT {
1011  static TClass *SmartIFlEIRndmGenSvcgR_Dictionary();
1012  static void SmartIFlEIRndmGenSvcgR_TClassManip(TClass*);
1013  static void *new_SmartIFlEIRndmGenSvcgR(void *p = 0);
1014  static void *newArray_SmartIFlEIRndmGenSvcgR(Long_t size, void *p);
1015  static void delete_SmartIFlEIRndmGenSvcgR(void *p);
1016  static void deleteArray_SmartIFlEIRndmGenSvcgR(void *p);
1017  static void destruct_SmartIFlEIRndmGenSvcgR(void *p);
1018 
1019  // Function generating the singleton type initializer
1020  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IRndmGenSvc>*)
1021  {
1022  ::SmartIF<IRndmGenSvc> *ptr = 0;
1023  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IRndmGenSvc>));
1024  static ::ROOT::TGenericClassInfo
1025  instance("SmartIF<IRndmGenSvc>", "GaudiKernel/SmartIF.h", 19,
1026  typeid(::SmartIF<IRndmGenSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1027  &SmartIFlEIRndmGenSvcgR_Dictionary, isa_proxy, 4,
1028  sizeof(::SmartIF<IRndmGenSvc>) );
1029  instance.SetNew(&new_SmartIFlEIRndmGenSvcgR);
1030  instance.SetNewArray(&newArray_SmartIFlEIRndmGenSvcgR);
1031  instance.SetDelete(&delete_SmartIFlEIRndmGenSvcgR);
1032  instance.SetDeleteArray(&deleteArray_SmartIFlEIRndmGenSvcgR);
1033  instance.SetDestructor(&destruct_SmartIFlEIRndmGenSvcgR);
1034  return &instance;
1035  }
1036  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IRndmGenSvc>*)
1037  {
1038  return GenerateInitInstanceLocal((::SmartIF<IRndmGenSvc>*)0);
1039  }
1040  // Static variable to force the class initialization
1041  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IRndmGenSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1042 
1043  // Dictionary for non-ClassDef classes
1044  static TClass *SmartIFlEIRndmGenSvcgR_Dictionary() {
1045  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IRndmGenSvc>*)0x0)->GetClass();
1046  SmartIFlEIRndmGenSvcgR_TClassManip(theClass);
1047  return theClass;
1048  }
1049 
1050  static void SmartIFlEIRndmGenSvcgR_TClassManip(TClass* ){
1051  }
1052 
1053 } // end of namespace ROOT
1054 
1055 namespace ROOT {
1056  static TClass *SmartIFlEIExceptionSvcgR_Dictionary();
1057  static void SmartIFlEIExceptionSvcgR_TClassManip(TClass*);
1058  static void *new_SmartIFlEIExceptionSvcgR(void *p = 0);
1059  static void *newArray_SmartIFlEIExceptionSvcgR(Long_t size, void *p);
1060  static void delete_SmartIFlEIExceptionSvcgR(void *p);
1061  static void deleteArray_SmartIFlEIExceptionSvcgR(void *p);
1062  static void destruct_SmartIFlEIExceptionSvcgR(void *p);
1063 
1064  // Function generating the singleton type initializer
1065  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IExceptionSvc>*)
1066  {
1067  ::SmartIF<IExceptionSvc> *ptr = 0;
1068  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IExceptionSvc>));
1069  static ::ROOT::TGenericClassInfo
1070  instance("SmartIF<IExceptionSvc>", "GaudiKernel/SmartIF.h", 19,
1071  typeid(::SmartIF<IExceptionSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1072  &SmartIFlEIExceptionSvcgR_Dictionary, isa_proxy, 4,
1073  sizeof(::SmartIF<IExceptionSvc>) );
1074  instance.SetNew(&new_SmartIFlEIExceptionSvcgR);
1075  instance.SetNewArray(&newArray_SmartIFlEIExceptionSvcgR);
1076  instance.SetDelete(&delete_SmartIFlEIExceptionSvcgR);
1077  instance.SetDeleteArray(&deleteArray_SmartIFlEIExceptionSvcgR);
1078  instance.SetDestructor(&destruct_SmartIFlEIExceptionSvcgR);
1079  return &instance;
1080  }
1081  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IExceptionSvc>*)
1082  {
1083  return GenerateInitInstanceLocal((::SmartIF<IExceptionSvc>*)0);
1084  }
1085  // Static variable to force the class initialization
1086  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IExceptionSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1087 
1088  // Dictionary for non-ClassDef classes
1089  static TClass *SmartIFlEIExceptionSvcgR_Dictionary() {
1090  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IExceptionSvc>*)0x0)->GetClass();
1091  SmartIFlEIExceptionSvcgR_TClassManip(theClass);
1092  return theClass;
1093  }
1094 
1095  static void SmartIFlEIExceptionSvcgR_TClassManip(TClass* ){
1096  }
1097 
1098 } // end of namespace ROOT
1099 
1100 namespace ROOT {
1101  static TClass *SmartIFlEITimelineSvcgR_Dictionary();
1102  static void SmartIFlEITimelineSvcgR_TClassManip(TClass*);
1103  static void *new_SmartIFlEITimelineSvcgR(void *p = 0);
1104  static void *newArray_SmartIFlEITimelineSvcgR(Long_t size, void *p);
1105  static void delete_SmartIFlEITimelineSvcgR(void *p);
1106  static void deleteArray_SmartIFlEITimelineSvcgR(void *p);
1107  static void destruct_SmartIFlEITimelineSvcgR(void *p);
1108 
1109  // Function generating the singleton type initializer
1110  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<ITimelineSvc>*)
1111  {
1112  ::SmartIF<ITimelineSvc> *ptr = 0;
1113  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<ITimelineSvc>));
1114  static ::ROOT::TGenericClassInfo
1115  instance("SmartIF<ITimelineSvc>", "GaudiKernel/SmartIF.h", 19,
1116  typeid(::SmartIF<ITimelineSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1117  &SmartIFlEITimelineSvcgR_Dictionary, isa_proxy, 4,
1118  sizeof(::SmartIF<ITimelineSvc>) );
1119  instance.SetNew(&new_SmartIFlEITimelineSvcgR);
1120  instance.SetNewArray(&newArray_SmartIFlEITimelineSvcgR);
1121  instance.SetDelete(&delete_SmartIFlEITimelineSvcgR);
1122  instance.SetDeleteArray(&deleteArray_SmartIFlEITimelineSvcgR);
1123  instance.SetDestructor(&destruct_SmartIFlEITimelineSvcgR);
1124  return &instance;
1125  }
1126  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<ITimelineSvc>*)
1127  {
1128  return GenerateInitInstanceLocal((::SmartIF<ITimelineSvc>*)0);
1129  }
1130  // Static variable to force the class initialization
1131  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<ITimelineSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1132 
1133  // Dictionary for non-ClassDef classes
1134  static TClass *SmartIFlEITimelineSvcgR_Dictionary() {
1135  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<ITimelineSvc>*)0x0)->GetClass();
1136  SmartIFlEITimelineSvcgR_TClassManip(theClass);
1137  return theClass;
1138  }
1139 
1140  static void SmartIFlEITimelineSvcgR_TClassManip(TClass* ){
1141  }
1142 
1143 } // end of namespace ROOT
1144 
1145 namespace ROOT {
1146  static TClass *SmartIFlEIHiveWhiteBoardgR_Dictionary();
1147  static void SmartIFlEIHiveWhiteBoardgR_TClassManip(TClass*);
1148  static void *new_SmartIFlEIHiveWhiteBoardgR(void *p = 0);
1149  static void *newArray_SmartIFlEIHiveWhiteBoardgR(Long_t size, void *p);
1150  static void delete_SmartIFlEIHiveWhiteBoardgR(void *p);
1151  static void deleteArray_SmartIFlEIHiveWhiteBoardgR(void *p);
1152  static void destruct_SmartIFlEIHiveWhiteBoardgR(void *p);
1153 
1154  // Function generating the singleton type initializer
1155  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IHiveWhiteBoard>*)
1156  {
1157  ::SmartIF<IHiveWhiteBoard> *ptr = 0;
1158  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IHiveWhiteBoard>));
1159  static ::ROOT::TGenericClassInfo
1160  instance("SmartIF<IHiveWhiteBoard>", "GaudiKernel/SmartIF.h", 19,
1161  typeid(::SmartIF<IHiveWhiteBoard>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1162  &SmartIFlEIHiveWhiteBoardgR_Dictionary, isa_proxy, 4,
1163  sizeof(::SmartIF<IHiveWhiteBoard>) );
1164  instance.SetNew(&new_SmartIFlEIHiveWhiteBoardgR);
1165  instance.SetNewArray(&newArray_SmartIFlEIHiveWhiteBoardgR);
1166  instance.SetDelete(&delete_SmartIFlEIHiveWhiteBoardgR);
1167  instance.SetDeleteArray(&deleteArray_SmartIFlEIHiveWhiteBoardgR);
1168  instance.SetDestructor(&destruct_SmartIFlEIHiveWhiteBoardgR);
1169  return &instance;
1170  }
1171  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IHiveWhiteBoard>*)
1172  {
1173  return GenerateInitInstanceLocal((::SmartIF<IHiveWhiteBoard>*)0);
1174  }
1175  // Static variable to force the class initialization
1176  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IHiveWhiteBoard>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1177 
1178  // Dictionary for non-ClassDef classes
1179  static TClass *SmartIFlEIHiveWhiteBoardgR_Dictionary() {
1180  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IHiveWhiteBoard>*)0x0)->GetClass();
1181  SmartIFlEIHiveWhiteBoardgR_TClassManip(theClass);
1182  return theClass;
1183  }
1184 
1185  static void SmartIFlEIHiveWhiteBoardgR_TClassManip(TClass* ){
1186  }
1187 
1188 } // end of namespace ROOT
1189 
1190 namespace ROOT {
1191  static TClass *SmartIFlEIAlgExecStateSvcgR_Dictionary();
1192  static void SmartIFlEIAlgExecStateSvcgR_TClassManip(TClass*);
1193  static void *new_SmartIFlEIAlgExecStateSvcgR(void *p = 0);
1194  static void *newArray_SmartIFlEIAlgExecStateSvcgR(Long_t size, void *p);
1195  static void delete_SmartIFlEIAlgExecStateSvcgR(void *p);
1196  static void deleteArray_SmartIFlEIAlgExecStateSvcgR(void *p);
1197  static void destruct_SmartIFlEIAlgExecStateSvcgR(void *p);
1198 
1199  // Function generating the singleton type initializer
1200  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IAlgExecStateSvc>*)
1201  {
1202  ::SmartIF<IAlgExecStateSvc> *ptr = 0;
1203  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IAlgExecStateSvc>));
1204  static ::ROOT::TGenericClassInfo
1205  instance("SmartIF<IAlgExecStateSvc>", "GaudiKernel/SmartIF.h", 19,
1206  typeid(::SmartIF<IAlgExecStateSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1207  &SmartIFlEIAlgExecStateSvcgR_Dictionary, isa_proxy, 4,
1208  sizeof(::SmartIF<IAlgExecStateSvc>) );
1209  instance.SetNew(&new_SmartIFlEIAlgExecStateSvcgR);
1210  instance.SetNewArray(&newArray_SmartIFlEIAlgExecStateSvcgR);
1211  instance.SetDelete(&delete_SmartIFlEIAlgExecStateSvcgR);
1212  instance.SetDeleteArray(&deleteArray_SmartIFlEIAlgExecStateSvcgR);
1213  instance.SetDestructor(&destruct_SmartIFlEIAlgExecStateSvcgR);
1214  return &instance;
1215  }
1216  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IAlgExecStateSvc>*)
1217  {
1218  return GenerateInitInstanceLocal((::SmartIF<IAlgExecStateSvc>*)0);
1219  }
1220  // Static variable to force the class initialization
1221  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IAlgExecStateSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1222 
1223  // Dictionary for non-ClassDef classes
1224  static TClass *SmartIFlEIAlgExecStateSvcgR_Dictionary() {
1225  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IAlgExecStateSvc>*)0x0)->GetClass();
1226  SmartIFlEIAlgExecStateSvcgR_TClassManip(theClass);
1227  return theClass;
1228  }
1229 
1230  static void SmartIFlEIAlgExecStateSvcgR_TClassManip(TClass* ){
1231  }
1232 
1233 } // end of namespace ROOT
1234 
1235 namespace ROOT {
1236  static TClass *SmartIFlEISvcManagergR_Dictionary();
1237  static void SmartIFlEISvcManagergR_TClassManip(TClass*);
1238  static void *new_SmartIFlEISvcManagergR(void *p = 0);
1239  static void *newArray_SmartIFlEISvcManagergR(Long_t size, void *p);
1240  static void delete_SmartIFlEISvcManagergR(void *p);
1241  static void deleteArray_SmartIFlEISvcManagergR(void *p);
1242  static void destruct_SmartIFlEISvcManagergR(void *p);
1243 
1244  // Function generating the singleton type initializer
1245  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<ISvcManager>*)
1246  {
1247  ::SmartIF<ISvcManager> *ptr = 0;
1248  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<ISvcManager>));
1249  static ::ROOT::TGenericClassInfo
1250  instance("SmartIF<ISvcManager>", "GaudiKernel/SmartIF.h", 19,
1251  typeid(::SmartIF<ISvcManager>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1252  &SmartIFlEISvcManagergR_Dictionary, isa_proxy, 4,
1253  sizeof(::SmartIF<ISvcManager>) );
1254  instance.SetNew(&new_SmartIFlEISvcManagergR);
1255  instance.SetNewArray(&newArray_SmartIFlEISvcManagergR);
1256  instance.SetDelete(&delete_SmartIFlEISvcManagergR);
1257  instance.SetDeleteArray(&deleteArray_SmartIFlEISvcManagergR);
1258  instance.SetDestructor(&destruct_SmartIFlEISvcManagergR);
1259  return &instance;
1260  }
1261  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<ISvcManager>*)
1262  {
1263  return GenerateInitInstanceLocal((::SmartIF<ISvcManager>*)0);
1264  }
1265  // Static variable to force the class initialization
1266  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<ISvcManager>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1267 
1268  // Dictionary for non-ClassDef classes
1269  static TClass *SmartIFlEISvcManagergR_Dictionary() {
1270  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<ISvcManager>*)0x0)->GetClass();
1271  SmartIFlEISvcManagergR_TClassManip(theClass);
1272  return theClass;
1273  }
1274 
1275  static void SmartIFlEISvcManagergR_TClassManip(TClass* ){
1276  }
1277 
1278 } // end of namespace ROOT
1279 
1280 namespace ROOT {
1281  static TClass *SmartIFlEIIncidentSvcgR_Dictionary();
1282  static void SmartIFlEIIncidentSvcgR_TClassManip(TClass*);
1283  static void *new_SmartIFlEIIncidentSvcgR(void *p = 0);
1284  static void *newArray_SmartIFlEIIncidentSvcgR(Long_t size, void *p);
1285  static void delete_SmartIFlEIIncidentSvcgR(void *p);
1286  static void deleteArray_SmartIFlEIIncidentSvcgR(void *p);
1287  static void destruct_SmartIFlEIIncidentSvcgR(void *p);
1288 
1289  // Function generating the singleton type initializer
1290  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IIncidentSvc>*)
1291  {
1292  ::SmartIF<IIncidentSvc> *ptr = 0;
1293  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IIncidentSvc>));
1294  static ::ROOT::TGenericClassInfo
1295  instance("SmartIF<IIncidentSvc>", "GaudiKernel/SmartIF.h", 19,
1296  typeid(::SmartIF<IIncidentSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1297  &SmartIFlEIIncidentSvcgR_Dictionary, isa_proxy, 4,
1298  sizeof(::SmartIF<IIncidentSvc>) );
1299  instance.SetNew(&new_SmartIFlEIIncidentSvcgR);
1300  instance.SetNewArray(&newArray_SmartIFlEIIncidentSvcgR);
1301  instance.SetDelete(&delete_SmartIFlEIIncidentSvcgR);
1302  instance.SetDeleteArray(&deleteArray_SmartIFlEIIncidentSvcgR);
1303  instance.SetDestructor(&destruct_SmartIFlEIIncidentSvcgR);
1304  return &instance;
1305  }
1306  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IIncidentSvc>*)
1307  {
1308  return GenerateInitInstanceLocal((::SmartIF<IIncidentSvc>*)0);
1309  }
1310  // Static variable to force the class initialization
1311  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IIncidentSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1312 
1313  // Dictionary for non-ClassDef classes
1314  static TClass *SmartIFlEIIncidentSvcgR_Dictionary() {
1315  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IIncidentSvc>*)0x0)->GetClass();
1316  SmartIFlEIIncidentSvcgR_TClassManip(theClass);
1317  return theClass;
1318  }
1319 
1320  static void SmartIFlEIIncidentSvcgR_TClassManip(TClass* ){
1321  }
1322 
1323 } // end of namespace ROOT
1324 
1325 namespace ROOT {
1326  static TClass *SmartIFlEIEvtSelectorgR_Dictionary();
1327  static void SmartIFlEIEvtSelectorgR_TClassManip(TClass*);
1328  static void *new_SmartIFlEIEvtSelectorgR(void *p = 0);
1329  static void *newArray_SmartIFlEIEvtSelectorgR(Long_t size, void *p);
1330  static void delete_SmartIFlEIEvtSelectorgR(void *p);
1331  static void deleteArray_SmartIFlEIEvtSelectorgR(void *p);
1332  static void destruct_SmartIFlEIEvtSelectorgR(void *p);
1333 
1334  // Function generating the singleton type initializer
1335  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IEvtSelector>*)
1336  {
1337  ::SmartIF<IEvtSelector> *ptr = 0;
1338  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IEvtSelector>));
1339  static ::ROOT::TGenericClassInfo
1340  instance("SmartIF<IEvtSelector>", "GaudiKernel/SmartIF.h", 19,
1341  typeid(::SmartIF<IEvtSelector>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1342  &SmartIFlEIEvtSelectorgR_Dictionary, isa_proxy, 4,
1343  sizeof(::SmartIF<IEvtSelector>) );
1344  instance.SetNew(&new_SmartIFlEIEvtSelectorgR);
1345  instance.SetNewArray(&newArray_SmartIFlEIEvtSelectorgR);
1346  instance.SetDelete(&delete_SmartIFlEIEvtSelectorgR);
1347  instance.SetDeleteArray(&deleteArray_SmartIFlEIEvtSelectorgR);
1348  instance.SetDestructor(&destruct_SmartIFlEIEvtSelectorgR);
1349  return &instance;
1350  }
1351  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IEvtSelector>*)
1352  {
1353  return GenerateInitInstanceLocal((::SmartIF<IEvtSelector>*)0);
1354  }
1355  // Static variable to force the class initialization
1356  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IEvtSelector>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1357 
1358  // Dictionary for non-ClassDef classes
1359  static TClass *SmartIFlEIEvtSelectorgR_Dictionary() {
1360  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IEvtSelector>*)0x0)->GetClass();
1361  SmartIFlEIEvtSelectorgR_TClassManip(theClass);
1362  return theClass;
1363  }
1364 
1365  static void SmartIFlEIEvtSelectorgR_TClassManip(TClass* ){
1366  }
1367 
1368 } // end of namespace ROOT
1369 
1370 namespace ROOT {
1371  static TClass *SmartIFlEISelectStatementgR_Dictionary();
1372  static void SmartIFlEISelectStatementgR_TClassManip(TClass*);
1373  static void *new_SmartIFlEISelectStatementgR(void *p = 0);
1374  static void *newArray_SmartIFlEISelectStatementgR(Long_t size, void *p);
1375  static void delete_SmartIFlEISelectStatementgR(void *p);
1376  static void deleteArray_SmartIFlEISelectStatementgR(void *p);
1377  static void destruct_SmartIFlEISelectStatementgR(void *p);
1378 
1379  // Function generating the singleton type initializer
1380  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<ISelectStatement>*)
1381  {
1382  ::SmartIF<ISelectStatement> *ptr = 0;
1383  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<ISelectStatement>));
1384  static ::ROOT::TGenericClassInfo
1385  instance("SmartIF<ISelectStatement>", "GaudiKernel/SmartIF.h", 19,
1386  typeid(::SmartIF<ISelectStatement>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1387  &SmartIFlEISelectStatementgR_Dictionary, isa_proxy, 4,
1388  sizeof(::SmartIF<ISelectStatement>) );
1389  instance.SetNew(&new_SmartIFlEISelectStatementgR);
1390  instance.SetNewArray(&newArray_SmartIFlEISelectStatementgR);
1391  instance.SetDelete(&delete_SmartIFlEISelectStatementgR);
1392  instance.SetDeleteArray(&deleteArray_SmartIFlEISelectStatementgR);
1393  instance.SetDestructor(&destruct_SmartIFlEISelectStatementgR);
1394  return &instance;
1395  }
1396  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<ISelectStatement>*)
1397  {
1398  return GenerateInitInstanceLocal((::SmartIF<ISelectStatement>*)0);
1399  }
1400  // Static variable to force the class initialization
1401  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<ISelectStatement>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1402 
1403  // Dictionary for non-ClassDef classes
1404  static TClass *SmartIFlEISelectStatementgR_Dictionary() {
1405  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<ISelectStatement>*)0x0)->GetClass();
1406  SmartIFlEISelectStatementgR_TClassManip(theClass);
1407  return theClass;
1408  }
1409 
1410  static void SmartIFlEISelectStatementgR_TClassManip(TClass* ){
1411  }
1412 
1413 } // end of namespace ROOT
1414 
1415 namespace ROOT {
1416  static TClass *SmartIFlEICounterSvcgR_Dictionary();
1417  static void SmartIFlEICounterSvcgR_TClassManip(TClass*);
1418  static void *new_SmartIFlEICounterSvcgR(void *p = 0);
1419  static void *newArray_SmartIFlEICounterSvcgR(Long_t size, void *p);
1420  static void delete_SmartIFlEICounterSvcgR(void *p);
1421  static void deleteArray_SmartIFlEICounterSvcgR(void *p);
1422  static void destruct_SmartIFlEICounterSvcgR(void *p);
1423 
1424  // Function generating the singleton type initializer
1425  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<ICounterSvc>*)
1426  {
1427  ::SmartIF<ICounterSvc> *ptr = 0;
1428  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<ICounterSvc>));
1429  static ::ROOT::TGenericClassInfo
1430  instance("SmartIF<ICounterSvc>", "GaudiKernel/SmartIF.h", 19,
1431  typeid(::SmartIF<ICounterSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1432  &SmartIFlEICounterSvcgR_Dictionary, isa_proxy, 4,
1433  sizeof(::SmartIF<ICounterSvc>) );
1434  instance.SetNew(&new_SmartIFlEICounterSvcgR);
1435  instance.SetNewArray(&newArray_SmartIFlEICounterSvcgR);
1436  instance.SetDelete(&delete_SmartIFlEICounterSvcgR);
1437  instance.SetDeleteArray(&deleteArray_SmartIFlEICounterSvcgR);
1438  instance.SetDestructor(&destruct_SmartIFlEICounterSvcgR);
1439  return &instance;
1440  }
1441  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<ICounterSvc>*)
1442  {
1443  return GenerateInitInstanceLocal((::SmartIF<ICounterSvc>*)0);
1444  }
1445  // Static variable to force the class initialization
1446  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<ICounterSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1447 
1448  // Dictionary for non-ClassDef classes
1449  static TClass *SmartIFlEICounterSvcgR_Dictionary() {
1450  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<ICounterSvc>*)0x0)->GetClass();
1451  SmartIFlEICounterSvcgR_TClassManip(theClass);
1452  return theClass;
1453  }
1454 
1455  static void SmartIFlEICounterSvcgR_TClassManip(TClass* ){
1456  }
1457 
1458 } // end of namespace ROOT
1459 
1460 namespace ROOT {
1461  static TClass *IProperty_Dictionary();
1462  static void IProperty_TClassManip(TClass*);
1463  static void delete_IProperty(void *p);
1464  static void deleteArray_IProperty(void *p);
1465  static void destruct_IProperty(void *p);
1466 
1467  // Function generating the singleton type initializer
1468  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IProperty*)
1469  {
1470  ::IProperty *ptr = 0;
1471  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IProperty));
1472  static ::ROOT::TGenericClassInfo
1473  instance("IProperty", "GaudiKernel/IProperty.h", 20,
1474  typeid(::IProperty), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1475  &IProperty_Dictionary, isa_proxy, 4,
1476  sizeof(::IProperty) );
1477  instance.SetDelete(&delete_IProperty);
1478  instance.SetDeleteArray(&deleteArray_IProperty);
1479  instance.SetDestructor(&destruct_IProperty);
1480  return &instance;
1481  }
1482  TGenericClassInfo *GenerateInitInstance(const ::IProperty*)
1483  {
1484  return GenerateInitInstanceLocal((::IProperty*)0);
1485  }
1486  // Static variable to force the class initialization
1487  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IProperty*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1488 
1489  // Dictionary for non-ClassDef classes
1490  static TClass *IProperty_Dictionary() {
1491  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IProperty*)0x0)->GetClass();
1492  IProperty_TClassManip(theClass);
1493  return theClass;
1494  }
1495 
1496  static void IProperty_TClassManip(TClass* ){
1497  }
1498 
1499 } // end of namespace ROOT
1500 
1501 namespace ROOT {
1502  static TClass *GaudicLcLDetailscLcLPropertyBase_Dictionary();
1503  static void GaudicLcLDetailscLcLPropertyBase_TClassManip(TClass*);
1504  static void delete_GaudicLcLDetailscLcLPropertyBase(void *p);
1505  static void deleteArray_GaudicLcLDetailscLcLPropertyBase(void *p);
1506  static void destruct_GaudicLcLDetailscLcLPropertyBase(void *p);
1507 
1508  // Function generating the singleton type initializer
1509  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Details::PropertyBase*)
1510  {
1511  ::Gaudi::Details::PropertyBase *ptr = 0;
1512  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Details::PropertyBase));
1513  static ::ROOT::TGenericClassInfo
1514  instance("Gaudi::Details::PropertyBase", "GaudiKernel/Property.h", 32,
1515  typeid(::Gaudi::Details::PropertyBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1516  &GaudicLcLDetailscLcLPropertyBase_Dictionary, isa_proxy, 4,
1517  sizeof(::Gaudi::Details::PropertyBase) );
1518  instance.SetDelete(&delete_GaudicLcLDetailscLcLPropertyBase);
1519  instance.SetDeleteArray(&deleteArray_GaudicLcLDetailscLcLPropertyBase);
1520  instance.SetDestructor(&destruct_GaudicLcLDetailscLcLPropertyBase);
1521  return &instance;
1522  }
1523  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Details::PropertyBase*)
1524  {
1525  return GenerateInitInstanceLocal((::Gaudi::Details::PropertyBase*)0);
1526  }
1527  // Static variable to force the class initialization
1528  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Details::PropertyBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1529 
1530  // Dictionary for non-ClassDef classes
1531  static TClass *GaudicLcLDetailscLcLPropertyBase_Dictionary() {
1532  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Details::PropertyBase*)0x0)->GetClass();
1533  GaudicLcLDetailscLcLPropertyBase_TClassManip(theClass);
1534  return theClass;
1535  }
1536 
1537  static void GaudicLcLDetailscLcLPropertyBase_TClassManip(TClass* ){
1538  }
1539 
1540 } // end of namespace ROOT
1541 
1542 namespace ROOT {
1543  static TClass *GaudiHandleProperty_Dictionary();
1544  static void GaudiHandleProperty_TClassManip(TClass*);
1545  static void delete_GaudiHandleProperty(void *p);
1546  static void deleteArray_GaudiHandleProperty(void *p);
1547  static void destruct_GaudiHandleProperty(void *p);
1548 
1549  // Function generating the singleton type initializer
1550  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHandleProperty*)
1551  {
1552  ::GaudiHandleProperty *ptr = 0;
1553  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHandleProperty));
1554  static ::ROOT::TGenericClassInfo
1555  instance("GaudiHandleProperty", "GaudiKernel/Property.h", 829,
1556  typeid(::GaudiHandleProperty), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1557  &GaudiHandleProperty_Dictionary, isa_proxy, 4,
1558  sizeof(::GaudiHandleProperty) );
1559  instance.SetDelete(&delete_GaudiHandleProperty);
1560  instance.SetDeleteArray(&deleteArray_GaudiHandleProperty);
1561  instance.SetDestructor(&destruct_GaudiHandleProperty);
1562  return &instance;
1563  }
1564  TGenericClassInfo *GenerateInitInstance(const ::GaudiHandleProperty*)
1565  {
1566  return GenerateInitInstanceLocal((::GaudiHandleProperty*)0);
1567  }
1568  // Static variable to force the class initialization
1569  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHandleProperty*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1570 
1571  // Dictionary for non-ClassDef classes
1572  static TClass *GaudiHandleProperty_Dictionary() {
1573  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHandleProperty*)0x0)->GetClass();
1574  GaudiHandleProperty_TClassManip(theClass);
1575  return theClass;
1576  }
1577 
1578  static void GaudiHandleProperty_TClassManip(TClass* ){
1579  }
1580 
1581 } // end of namespace ROOT
1582 
1583 namespace ROOT {
1584  static TClass *GaudiHandleArrayProperty_Dictionary();
1585  static void GaudiHandleArrayProperty_TClassManip(TClass*);
1586  static void delete_GaudiHandleArrayProperty(void *p);
1587  static void deleteArray_GaudiHandleArrayProperty(void *p);
1588  static void destruct_GaudiHandleArrayProperty(void *p);
1589 
1590  // Function generating the singleton type initializer
1591  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHandleArrayProperty*)
1592  {
1593  ::GaudiHandleArrayProperty *ptr = 0;
1594  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHandleArrayProperty));
1595  static ::ROOT::TGenericClassInfo
1596  instance("GaudiHandleArrayProperty", "GaudiKernel/Property.h", 869,
1597  typeid(::GaudiHandleArrayProperty), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1598  &GaudiHandleArrayProperty_Dictionary, isa_proxy, 4,
1599  sizeof(::GaudiHandleArrayProperty) );
1600  instance.SetDelete(&delete_GaudiHandleArrayProperty);
1601  instance.SetDeleteArray(&deleteArray_GaudiHandleArrayProperty);
1602  instance.SetDestructor(&destruct_GaudiHandleArrayProperty);
1603  return &instance;
1604  }
1605  TGenericClassInfo *GenerateInitInstance(const ::GaudiHandleArrayProperty*)
1606  {
1607  return GenerateInitInstanceLocal((::GaudiHandleArrayProperty*)0);
1608  }
1609  // Static variable to force the class initialization
1610  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHandleArrayProperty*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1611 
1612  // Dictionary for non-ClassDef classes
1613  static TClass *GaudiHandleArrayProperty_Dictionary() {
1614  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHandleArrayProperty*)0x0)->GetClass();
1615  GaudiHandleArrayProperty_TClassManip(theClass);
1616  return theClass;
1617  }
1618 
1619  static void GaudiHandleArrayProperty_TClassManip(TClass* ){
1620  }
1621 
1622 } // end of namespace ROOT
1623 
1624 namespace ROOT {
1625  static TClass *ISvcManager_Dictionary();
1626  static void ISvcManager_TClassManip(TClass*);
1627  static void delete_ISvcManager(void *p);
1628  static void deleteArray_ISvcManager(void *p);
1629  static void destruct_ISvcManager(void *p);
1630 
1631  // Function generating the singleton type initializer
1632  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ISvcManager*)
1633  {
1634  ::ISvcManager *ptr = 0;
1635  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ISvcManager));
1636  static ::ROOT::TGenericClassInfo
1637  instance("ISvcManager", "GaudiKernel/ISvcManager.h", 28,
1638  typeid(::ISvcManager), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1639  &ISvcManager_Dictionary, isa_proxy, 4,
1640  sizeof(::ISvcManager) );
1641  instance.SetDelete(&delete_ISvcManager);
1642  instance.SetDeleteArray(&deleteArray_ISvcManager);
1643  instance.SetDestructor(&destruct_ISvcManager);
1644  return &instance;
1645  }
1646  TGenericClassInfo *GenerateInitInstance(const ::ISvcManager*)
1647  {
1648  return GenerateInitInstanceLocal((::ISvcManager*)0);
1649  }
1650  // Static variable to force the class initialization
1651  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ISvcManager*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1652 
1653  // Dictionary for non-ClassDef classes
1654  static TClass *ISvcManager_Dictionary() {
1655  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ISvcManager*)0x0)->GetClass();
1656  ISvcManager_TClassManip(theClass);
1657  return theClass;
1658  }
1659 
1660  static void ISvcManager_TClassManip(TClass* ){
1661  }
1662 
1663 } // end of namespace ROOT
1664 
1665 namespace ROOT {
1666  static TClass *ISvcLocator_Dictionary();
1667  static void ISvcLocator_TClassManip(TClass*);
1668  static void delete_ISvcLocator(void *p);
1669  static void deleteArray_ISvcLocator(void *p);
1670  static void destruct_ISvcLocator(void *p);
1671 
1672  // Function generating the singleton type initializer
1673  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ISvcLocator*)
1674  {
1675  ::ISvcLocator *ptr = 0;
1676  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ISvcLocator));
1677  static ::ROOT::TGenericClassInfo
1678  instance("ISvcLocator", "GaudiKernel/ISvcLocator.h", 25,
1679  typeid(::ISvcLocator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1680  &ISvcLocator_Dictionary, isa_proxy, 4,
1681  sizeof(::ISvcLocator) );
1682  instance.SetDelete(&delete_ISvcLocator);
1683  instance.SetDeleteArray(&deleteArray_ISvcLocator);
1684  instance.SetDestructor(&destruct_ISvcLocator);
1685  return &instance;
1686  }
1687  TGenericClassInfo *GenerateInitInstance(const ::ISvcLocator*)
1688  {
1689  return GenerateInitInstanceLocal((::ISvcLocator*)0);
1690  }
1691  // Static variable to force the class initialization
1692  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ISvcLocator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1693 
1694  // Dictionary for non-ClassDef classes
1695  static TClass *ISvcLocator_Dictionary() {
1696  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ISvcLocator*)0x0)->GetClass();
1697  ISvcLocator_TClassManip(theClass);
1698  return theClass;
1699  }
1700 
1701  static void ISvcLocator_TClassManip(TClass* ){
1702  }
1703 
1704 } // end of namespace ROOT
1705 
1706 namespace ROOT {
1707  static TClass *IAlgTool_Dictionary();
1708  static void IAlgTool_TClassManip(TClass*);
1709  static void delete_IAlgTool(void *p);
1710  static void deleteArray_IAlgTool(void *p);
1711  static void destruct_IAlgTool(void *p);
1712 
1713  // Function generating the singleton type initializer
1714  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAlgTool*)
1715  {
1716  ::IAlgTool *ptr = 0;
1717  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAlgTool));
1718  static ::ROOT::TGenericClassInfo
1719  instance("IAlgTool", "GaudiKernel/IAlgTool.h", 23,
1720  typeid(::IAlgTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1721  &IAlgTool_Dictionary, isa_proxy, 4,
1722  sizeof(::IAlgTool) );
1723  instance.SetDelete(&delete_IAlgTool);
1724  instance.SetDeleteArray(&deleteArray_IAlgTool);
1725  instance.SetDestructor(&destruct_IAlgTool);
1726  return &instance;
1727  }
1728  TGenericClassInfo *GenerateInitInstance(const ::IAlgTool*)
1729  {
1730  return GenerateInitInstanceLocal((::IAlgTool*)0);
1731  }
1732  // Static variable to force the class initialization
1733  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAlgTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1734 
1735  // Dictionary for non-ClassDef classes
1736  static TClass *IAlgTool_Dictionary() {
1737  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAlgTool*)0x0)->GetClass();
1738  IAlgTool_TClassManip(theClass);
1739  return theClass;
1740  }
1741 
1742  static void IAlgTool_TClassManip(TClass* ){
1743  }
1744 
1745 } // end of namespace ROOT
1746 
1747 namespace ROOT {
1748  static TClass *IAuditor_Dictionary();
1749  static void IAuditor_TClassManip(TClass*);
1750  static void delete_IAuditor(void *p);
1751  static void deleteArray_IAuditor(void *p);
1752  static void destruct_IAuditor(void *p);
1753 
1754  // Function generating the singleton type initializer
1755  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAuditor*)
1756  {
1757  ::IAuditor *ptr = 0;
1758  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAuditor));
1759  static ::ROOT::TGenericClassInfo
1760  instance("IAuditor", "GaudiKernel/IAuditor.h", 18,
1761  typeid(::IAuditor), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1762  &IAuditor_Dictionary, isa_proxy, 4,
1763  sizeof(::IAuditor) );
1764  instance.SetDelete(&delete_IAuditor);
1765  instance.SetDeleteArray(&deleteArray_IAuditor);
1766  instance.SetDestructor(&destruct_IAuditor);
1767  return &instance;
1768  }
1769  TGenericClassInfo *GenerateInitInstance(const ::IAuditor*)
1770  {
1771  return GenerateInitInstanceLocal((::IAuditor*)0);
1772  }
1773  // Static variable to force the class initialization
1774  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAuditor*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1775 
1776  // Dictionary for non-ClassDef classes
1777  static TClass *IAuditor_Dictionary() {
1778  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAuditor*)0x0)->GetClass();
1779  IAuditor_TClassManip(theClass);
1780  return theClass;
1781  }
1782 
1783  static void IAuditor_TClassManip(TClass* ){
1784  }
1785 
1786 } // end of namespace ROOT
1787 
1788 namespace ROOT {
1789  static TClass *IAuditorSvc_Dictionary();
1790  static void IAuditorSvc_TClassManip(TClass*);
1791  static void delete_IAuditorSvc(void *p);
1792  static void deleteArray_IAuditorSvc(void *p);
1793  static void destruct_IAuditorSvc(void *p);
1794 
1795  // Function generating the singleton type initializer
1796  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAuditorSvc*)
1797  {
1798  ::IAuditorSvc *ptr = 0;
1799  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAuditorSvc));
1800  static ::ROOT::TGenericClassInfo
1801  instance("IAuditorSvc", "GaudiKernel/IAuditorSvc.h", 15,
1802  typeid(::IAuditorSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1803  &IAuditorSvc_Dictionary, isa_proxy, 4,
1804  sizeof(::IAuditorSvc) );
1805  instance.SetDelete(&delete_IAuditorSvc);
1806  instance.SetDeleteArray(&deleteArray_IAuditorSvc);
1807  instance.SetDestructor(&destruct_IAuditorSvc);
1808  return &instance;
1809  }
1810  TGenericClassInfo *GenerateInitInstance(const ::IAuditorSvc*)
1811  {
1812  return GenerateInitInstanceLocal((::IAuditorSvc*)0);
1813  }
1814  // Static variable to force the class initialization
1815  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAuditorSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1816 
1817  // Dictionary for non-ClassDef classes
1818  static TClass *IAuditorSvc_Dictionary() {
1819  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAuditorSvc*)0x0)->GetClass();
1820  IAuditorSvc_TClassManip(theClass);
1821  return theClass;
1822  }
1823 
1824  static void IAuditorSvc_TClassManip(TClass* ){
1825  }
1826 
1827 } // end of namespace ROOT
1828 
1829 namespace ROOT {
1830  static TClass *IDataProviderSvc_Dictionary();
1831  static void IDataProviderSvc_TClassManip(TClass*);
1832  static void delete_IDataProviderSvc(void *p);
1833  static void deleteArray_IDataProviderSvc(void *p);
1834  static void destruct_IDataProviderSvc(void *p);
1835 
1836  // Function generating the singleton type initializer
1837  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDataProviderSvc*)
1838  {
1839  ::IDataProviderSvc *ptr = 0;
1840  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDataProviderSvc));
1841  static ::ROOT::TGenericClassInfo
1842  instance("IDataProviderSvc", "GaudiKernel/IDataProviderSvc.h", 45,
1843  typeid(::IDataProviderSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1844  &IDataProviderSvc_Dictionary, isa_proxy, 4,
1845  sizeof(::IDataProviderSvc) );
1846  instance.SetDelete(&delete_IDataProviderSvc);
1847  instance.SetDeleteArray(&deleteArray_IDataProviderSvc);
1848  instance.SetDestructor(&destruct_IDataProviderSvc);
1849  return &instance;
1850  }
1851  TGenericClassInfo *GenerateInitInstance(const ::IDataProviderSvc*)
1852  {
1853  return GenerateInitInstanceLocal((::IDataProviderSvc*)0);
1854  }
1855  // Static variable to force the class initialization
1856  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDataProviderSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1857 
1858  // Dictionary for non-ClassDef classes
1859  static TClass *IDataProviderSvc_Dictionary() {
1860  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDataProviderSvc*)0x0)->GetClass();
1861  IDataProviderSvc_TClassManip(theClass);
1862  return theClass;
1863  }
1864 
1865  static void IDataProviderSvc_TClassManip(TClass* ){
1866  }
1867 
1868 } // end of namespace ROOT
1869 
1870 namespace ROOT {
1871  static TClass *IMonitorSvc_Dictionary();
1872  static void IMonitorSvc_TClassManip(TClass*);
1873  static void delete_IMonitorSvc(void *p);
1874  static void deleteArray_IMonitorSvc(void *p);
1875  static void destruct_IMonitorSvc(void *p);
1876 
1877  // Function generating the singleton type initializer
1878  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IMonitorSvc*)
1879  {
1880  ::IMonitorSvc *ptr = 0;
1881  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IMonitorSvc));
1882  static ::ROOT::TGenericClassInfo
1883  instance("IMonitorSvc", "GaudiKernel/IMonitorSvc.h", 24,
1884  typeid(::IMonitorSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1885  &IMonitorSvc_Dictionary, isa_proxy, 4,
1886  sizeof(::IMonitorSvc) );
1887  instance.SetDelete(&delete_IMonitorSvc);
1888  instance.SetDeleteArray(&deleteArray_IMonitorSvc);
1889  instance.SetDestructor(&destruct_IMonitorSvc);
1890  return &instance;
1891  }
1892  TGenericClassInfo *GenerateInitInstance(const ::IMonitorSvc*)
1893  {
1894  return GenerateInitInstanceLocal((::IMonitorSvc*)0);
1895  }
1896  // Static variable to force the class initialization
1897  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IMonitorSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1898 
1899  // Dictionary for non-ClassDef classes
1900  static TClass *IMonitorSvc_Dictionary() {
1901  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IMonitorSvc*)0x0)->GetClass();
1902  IMonitorSvc_TClassManip(theClass);
1903  return theClass;
1904  }
1905 
1906  static void IMonitorSvc_TClassManip(TClass* ){
1907  }
1908 
1909 } // end of namespace ROOT
1910 
1911 namespace ROOT {
1912  static TClass *IToolSvc_Dictionary();
1913  static void IToolSvc_TClassManip(TClass*);
1914  static void delete_IToolSvc(void *p);
1915  static void deleteArray_IToolSvc(void *p);
1916  static void destruct_IToolSvc(void *p);
1917 
1918  // Function generating the singleton type initializer
1919  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IToolSvc*)
1920  {
1921  ::IToolSvc *ptr = 0;
1922  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IToolSvc));
1923  static ::ROOT::TGenericClassInfo
1924  instance("IToolSvc", "GaudiKernel/IToolSvc.h", 19,
1925  typeid(::IToolSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1926  &IToolSvc_Dictionary, isa_proxy, 4,
1927  sizeof(::IToolSvc) );
1928  instance.SetDelete(&delete_IToolSvc);
1929  instance.SetDeleteArray(&deleteArray_IToolSvc);
1930  instance.SetDestructor(&destruct_IToolSvc);
1931  return &instance;
1932  }
1933  TGenericClassInfo *GenerateInitInstance(const ::IToolSvc*)
1934  {
1935  return GenerateInitInstanceLocal((::IToolSvc*)0);
1936  }
1937  // Static variable to force the class initialization
1938  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IToolSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1939 
1940  // Dictionary for non-ClassDef classes
1941  static TClass *IToolSvc_Dictionary() {
1942  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IToolSvc*)0x0)->GetClass();
1943  IToolSvc_TClassManip(theClass);
1944  return theClass;
1945  }
1946 
1947  static void IToolSvc_TClassManip(TClass* ){
1948  }
1949 
1950 } // end of namespace ROOT
1951 
1952 namespace ROOT {
1953  static TClass *DataObjectHandleProperty_Dictionary();
1954  static void DataObjectHandleProperty_TClassManip(TClass*);
1955  static void delete_DataObjectHandleProperty(void *p);
1956  static void deleteArray_DataObjectHandleProperty(void *p);
1957  static void destruct_DataObjectHandleProperty(void *p);
1958 
1959  // Function generating the singleton type initializer
1960  static TGenericClassInfo *GenerateInitInstanceLocal(const ::DataObjectHandleProperty*)
1961  {
1962  ::DataObjectHandleProperty *ptr = 0;
1963  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::DataObjectHandleProperty));
1964  static ::ROOT::TGenericClassInfo
1965  instance("DataObjectHandleProperty", "GaudiKernel/DataObjectHandleProperty.h", 23,
1966  typeid(::DataObjectHandleProperty), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1967  &DataObjectHandleProperty_Dictionary, isa_proxy, 4,
1968  sizeof(::DataObjectHandleProperty) );
1969  instance.SetDelete(&delete_DataObjectHandleProperty);
1970  instance.SetDeleteArray(&deleteArray_DataObjectHandleProperty);
1971  instance.SetDestructor(&destruct_DataObjectHandleProperty);
1972  return &instance;
1973  }
1974  TGenericClassInfo *GenerateInitInstance(const ::DataObjectHandleProperty*)
1975  {
1976  return GenerateInitInstanceLocal((::DataObjectHandleProperty*)0);
1977  }
1978  // Static variable to force the class initialization
1979  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DataObjectHandleProperty*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1980 
1981  // Dictionary for non-ClassDef classes
1982  static TClass *DataObjectHandleProperty_Dictionary() {
1983  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::DataObjectHandleProperty*)0x0)->GetClass();
1984  DataObjectHandleProperty_TClassManip(theClass);
1985  return theClass;
1986  }
1987 
1988  static void DataObjectHandleProperty_TClassManip(TClass* ){
1989  }
1990 
1991 } // end of namespace ROOT
1992 
1993 namespace ROOT {
1994  static TClass *GaudiHandleInfo_Dictionary();
1995  static void GaudiHandleInfo_TClassManip(TClass*);
1996  static void delete_GaudiHandleInfo(void *p);
1997  static void deleteArray_GaudiHandleInfo(void *p);
1998  static void destruct_GaudiHandleInfo(void *p);
1999 
2000  // Function generating the singleton type initializer
2001  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHandleInfo*)
2002  {
2003  ::GaudiHandleInfo *ptr = 0;
2004  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHandleInfo));
2005  static ::ROOT::TGenericClassInfo
2006  instance("GaudiHandleInfo", "GaudiKernel/GaudiHandle.h", 16,
2007  typeid(::GaudiHandleInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2008  &GaudiHandleInfo_Dictionary, isa_proxy, 4,
2009  sizeof(::GaudiHandleInfo) );
2010  instance.SetDelete(&delete_GaudiHandleInfo);
2011  instance.SetDeleteArray(&deleteArray_GaudiHandleInfo);
2012  instance.SetDestructor(&destruct_GaudiHandleInfo);
2013  return &instance;
2014  }
2015  TGenericClassInfo *GenerateInitInstance(const ::GaudiHandleInfo*)
2016  {
2017  return GenerateInitInstanceLocal((::GaudiHandleInfo*)0);
2018  }
2019  // Static variable to force the class initialization
2020  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHandleInfo*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2021 
2022  // Dictionary for non-ClassDef classes
2023  static TClass *GaudiHandleInfo_Dictionary() {
2024  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHandleInfo*)0x0)->GetClass();
2025  GaudiHandleInfo_TClassManip(theClass);
2026  return theClass;
2027  }
2028 
2029  static void GaudiHandleInfo_TClassManip(TClass* ){
2030  }
2031 
2032 } // end of namespace ROOT
2033 
2034 namespace ROOT {
2035  static TClass *GaudiHandleBase_Dictionary();
2036  static void GaudiHandleBase_TClassManip(TClass*);
2037  static void delete_GaudiHandleBase(void *p);
2038  static void deleteArray_GaudiHandleBase(void *p);
2039  static void destruct_GaudiHandleBase(void *p);
2040 
2041  // Function generating the singleton type initializer
2042  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHandleBase*)
2043  {
2044  ::GaudiHandleBase *ptr = 0;
2045  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHandleBase));
2046  static ::ROOT::TGenericClassInfo
2047  instance("GaudiHandleBase", "GaudiKernel/GaudiHandle.h", 83,
2048  typeid(::GaudiHandleBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2049  &GaudiHandleBase_Dictionary, isa_proxy, 4,
2050  sizeof(::GaudiHandleBase) );
2051  instance.SetDelete(&delete_GaudiHandleBase);
2052  instance.SetDeleteArray(&deleteArray_GaudiHandleBase);
2053  instance.SetDestructor(&destruct_GaudiHandleBase);
2054  return &instance;
2055  }
2056  TGenericClassInfo *GenerateInitInstance(const ::GaudiHandleBase*)
2057  {
2058  return GenerateInitInstanceLocal((::GaudiHandleBase*)0);
2059  }
2060  // Static variable to force the class initialization
2061  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHandleBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2062 
2063  // Dictionary for non-ClassDef classes
2064  static TClass *GaudiHandleBase_Dictionary() {
2065  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHandleBase*)0x0)->GetClass();
2066  GaudiHandleBase_TClassManip(theClass);
2067  return theClass;
2068  }
2069 
2070  static void GaudiHandleBase_TClassManip(TClass* ){
2071  }
2072 
2073 } // end of namespace ROOT
2074 
2075 namespace ROOT {
2076  static TClass *GaudiHandleArrayBase_Dictionary();
2077  static void GaudiHandleArrayBase_TClassManip(TClass*);
2078  static void delete_GaudiHandleArrayBase(void *p);
2079  static void deleteArray_GaudiHandleArrayBase(void *p);
2080  static void destruct_GaudiHandleArrayBase(void *p);
2081 
2082  // Function generating the singleton type initializer
2083  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHandleArrayBase*)
2084  {
2085  ::GaudiHandleArrayBase *ptr = 0;
2086  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHandleArrayBase));
2087  static ::ROOT::TGenericClassInfo
2088  instance("GaudiHandleArrayBase", "GaudiKernel/GaudiHandle.h", 348,
2089  typeid(::GaudiHandleArrayBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2090  &GaudiHandleArrayBase_Dictionary, isa_proxy, 4,
2091  sizeof(::GaudiHandleArrayBase) );
2092  instance.SetDelete(&delete_GaudiHandleArrayBase);
2093  instance.SetDeleteArray(&deleteArray_GaudiHandleArrayBase);
2094  instance.SetDestructor(&destruct_GaudiHandleArrayBase);
2095  return &instance;
2096  }
2097  TGenericClassInfo *GenerateInitInstance(const ::GaudiHandleArrayBase*)
2098  {
2099  return GenerateInitInstanceLocal((::GaudiHandleArrayBase*)0);
2100  }
2101  // Static variable to force the class initialization
2102  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHandleArrayBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2103 
2104  // Dictionary for non-ClassDef classes
2105  static TClass *GaudiHandleArrayBase_Dictionary() {
2106  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHandleArrayBase*)0x0)->GetClass();
2107  GaudiHandleArrayBase_TClassManip(theClass);
2108  return theClass;
2109  }
2110 
2111  static void GaudiHandleArrayBase_TClassManip(TClass* ){
2112  }
2113 
2114 } // end of namespace ROOT
2115 
2116 namespace ROOT {
2117  static TClass *AlgTool_Dictionary();
2118  static void AlgTool_TClassManip(TClass*);
2119  static void delete_AlgTool(void *p);
2120  static void deleteArray_AlgTool(void *p);
2121  static void destruct_AlgTool(void *p);
2122 
2123  // Function generating the singleton type initializer
2124  static TGenericClassInfo *GenerateInitInstanceLocal(const ::AlgTool*)
2125  {
2126  ::AlgTool *ptr = 0;
2127  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AlgTool));
2128  static ::ROOT::TGenericClassInfo
2129  instance("AlgTool", "GaudiKernel/AlgTool.h", 48,
2130  typeid(::AlgTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2131  &AlgTool_Dictionary, isa_proxy, 4,
2132  sizeof(::AlgTool) );
2133  instance.SetDelete(&delete_AlgTool);
2134  instance.SetDeleteArray(&deleteArray_AlgTool);
2135  instance.SetDestructor(&destruct_AlgTool);
2136  return &instance;
2137  }
2138  TGenericClassInfo *GenerateInitInstance(const ::AlgTool*)
2139  {
2140  return GenerateInitInstanceLocal((::AlgTool*)0);
2141  }
2142  // Static variable to force the class initialization
2143  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AlgTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2144 
2145  // Dictionary for non-ClassDef classes
2146  static TClass *AlgTool_Dictionary() {
2147  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AlgTool*)0x0)->GetClass();
2148  AlgTool_TClassManip(theClass);
2149  return theClass;
2150  }
2151 
2152  static void AlgTool_TClassManip(TClass* ){
2153  }
2154 
2155 } // end of namespace ROOT
2156 
2157 namespace ROOT {
2158  static TClass *IAlgorithm_Dictionary();
2159  static void IAlgorithm_TClassManip(TClass*);
2160  static void delete_IAlgorithm(void *p);
2161  static void deleteArray_IAlgorithm(void *p);
2162  static void destruct_IAlgorithm(void *p);
2163 
2164  // Function generating the singleton type initializer
2165  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAlgorithm*)
2166  {
2167  ::IAlgorithm *ptr = 0;
2168  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAlgorithm));
2169  static ::ROOT::TGenericClassInfo
2170  instance("IAlgorithm", "GaudiKernel/IAlgorithm.h", 28,
2171  typeid(::IAlgorithm), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2172  &IAlgorithm_Dictionary, isa_proxy, 4,
2173  sizeof(::IAlgorithm) );
2174  instance.SetDelete(&delete_IAlgorithm);
2175  instance.SetDeleteArray(&deleteArray_IAlgorithm);
2176  instance.SetDestructor(&destruct_IAlgorithm);
2177  return &instance;
2178  }
2179  TGenericClassInfo *GenerateInitInstance(const ::IAlgorithm*)
2180  {
2181  return GenerateInitInstanceLocal((::IAlgorithm*)0);
2182  }
2183  // Static variable to force the class initialization
2184  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAlgorithm*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2185 
2186  // Dictionary for non-ClassDef classes
2187  static TClass *IAlgorithm_Dictionary() {
2188  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAlgorithm*)0x0)->GetClass();
2189  IAlgorithm_TClassManip(theClass);
2190  return theClass;
2191  }
2192 
2193  static void IAlgorithm_TClassManip(TClass* ){
2194  }
2195 
2196 } // end of namespace ROOT
2197 
2198 namespace ROOT {
2199  static TClass *IAlgContextSvc_Dictionary();
2200  static void IAlgContextSvc_TClassManip(TClass*);
2201  static void delete_IAlgContextSvc(void *p);
2202  static void deleteArray_IAlgContextSvc(void *p);
2203  static void destruct_IAlgContextSvc(void *p);
2204 
2205  // Function generating the singleton type initializer
2206  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAlgContextSvc*)
2207  {
2208  ::IAlgContextSvc *ptr = 0;
2209  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAlgContextSvc));
2210  static ::ROOT::TGenericClassInfo
2211  instance("IAlgContextSvc", "GaudiKernel/IAlgContextSvc.h", 23,
2212  typeid(::IAlgContextSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2213  &IAlgContextSvc_Dictionary, isa_proxy, 4,
2214  sizeof(::IAlgContextSvc) );
2215  instance.SetDelete(&delete_IAlgContextSvc);
2216  instance.SetDeleteArray(&deleteArray_IAlgContextSvc);
2217  instance.SetDestructor(&destruct_IAlgContextSvc);
2218  return &instance;
2219  }
2220  TGenericClassInfo *GenerateInitInstance(const ::IAlgContextSvc*)
2221  {
2222  return GenerateInitInstanceLocal((::IAlgContextSvc*)0);
2223  }
2224  // Static variable to force the class initialization
2225  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAlgContextSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2226 
2227  // Dictionary for non-ClassDef classes
2228  static TClass *IAlgContextSvc_Dictionary() {
2229  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAlgContextSvc*)0x0)->GetClass();
2230  IAlgContextSvc_TClassManip(theClass);
2231  return theClass;
2232  }
2233 
2234  static void IAlgContextSvc_TClassManip(TClass* ){
2235  }
2236 
2237 } // end of namespace ROOT
2238 
2239 namespace ROOT {
2240  static TClass *IChronoSvc_Dictionary();
2241  static void IChronoSvc_TClassManip(TClass*);
2242  static void delete_IChronoSvc(void *p);
2243  static void deleteArray_IChronoSvc(void *p);
2244  static void destruct_IChronoSvc(void *p);
2245 
2246  // Function generating the singleton type initializer
2247  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IChronoSvc*)
2248  {
2249  ::IChronoSvc *ptr = 0;
2250  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IChronoSvc));
2251  static ::ROOT::TGenericClassInfo
2252  instance("IChronoSvc", "GaudiKernel/IChronoSvc.h", 31,
2253  typeid(::IChronoSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2254  &IChronoSvc_Dictionary, isa_proxy, 4,
2255  sizeof(::IChronoSvc) );
2256  instance.SetDelete(&delete_IChronoSvc);
2257  instance.SetDeleteArray(&deleteArray_IChronoSvc);
2258  instance.SetDestructor(&destruct_IChronoSvc);
2259  return &instance;
2260  }
2261  TGenericClassInfo *GenerateInitInstance(const ::IChronoSvc*)
2262  {
2263  return GenerateInitInstanceLocal((::IChronoSvc*)0);
2264  }
2265  // Static variable to force the class initialization
2266  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IChronoSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2267 
2268  // Dictionary for non-ClassDef classes
2269  static TClass *IChronoSvc_Dictionary() {
2270  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IChronoSvc*)0x0)->GetClass();
2271  IChronoSvc_TClassManip(theClass);
2272  return theClass;
2273  }
2274 
2275  static void IChronoSvc_TClassManip(TClass* ){
2276  }
2277 
2278 } // end of namespace ROOT
2279 
2280 namespace ROOT {
2281  static TClass *IStatSvc_Dictionary();
2282  static void IStatSvc_TClassManip(TClass*);
2283  static void delete_IStatSvc(void *p);
2284  static void deleteArray_IStatSvc(void *p);
2285  static void destruct_IStatSvc(void *p);
2286 
2287  // Function generating the singleton type initializer
2288  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IStatSvc*)
2289  {
2290  ::IStatSvc *ptr = 0;
2291  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IStatSvc));
2292  static ::ROOT::TGenericClassInfo
2293  instance("IStatSvc", "GaudiKernel/IStatSvc.h", 25,
2294  typeid(::IStatSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2295  &IStatSvc_Dictionary, isa_proxy, 4,
2296  sizeof(::IStatSvc) );
2297  instance.SetDelete(&delete_IStatSvc);
2298  instance.SetDeleteArray(&deleteArray_IStatSvc);
2299  instance.SetDestructor(&destruct_IStatSvc);
2300  return &instance;
2301  }
2302  TGenericClassInfo *GenerateInitInstance(const ::IStatSvc*)
2303  {
2304  return GenerateInitInstanceLocal((::IStatSvc*)0);
2305  }
2306  // Static variable to force the class initialization
2307  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IStatSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2308 
2309  // Dictionary for non-ClassDef classes
2310  static TClass *IStatSvc_Dictionary() {
2311  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IStatSvc*)0x0)->GetClass();
2312  IStatSvc_TClassManip(theClass);
2313  return theClass;
2314  }
2315 
2316  static void IStatSvc_TClassManip(TClass* ){
2317  }
2318 
2319 } // end of namespace ROOT
2320 
2321 namespace ROOT {
2322  static TClass *IChronoStatSvc_Dictionary();
2323  static void IChronoStatSvc_TClassManip(TClass*);
2324  static void delete_IChronoStatSvc(void *p);
2325  static void deleteArray_IChronoStatSvc(void *p);
2326  static void destruct_IChronoStatSvc(void *p);
2327 
2328  // Function generating the singleton type initializer
2329  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IChronoStatSvc*)
2330  {
2331  ::IChronoStatSvc *ptr = 0;
2332  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IChronoStatSvc));
2333  static ::ROOT::TGenericClassInfo
2334  instance("IChronoStatSvc", "GaudiKernel/IChronoStatSvc.h", 33,
2335  typeid(::IChronoStatSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2336  &IChronoStatSvc_Dictionary, isa_proxy, 4,
2337  sizeof(::IChronoStatSvc) );
2338  instance.SetDelete(&delete_IChronoStatSvc);
2339  instance.SetDeleteArray(&deleteArray_IChronoStatSvc);
2340  instance.SetDestructor(&destruct_IChronoStatSvc);
2341  return &instance;
2342  }
2343  TGenericClassInfo *GenerateInitInstance(const ::IChronoStatSvc*)
2344  {
2345  return GenerateInitInstanceLocal((::IChronoStatSvc*)0);
2346  }
2347  // Static variable to force the class initialization
2348  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IChronoStatSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2349 
2350  // Dictionary for non-ClassDef classes
2351  static TClass *IChronoStatSvc_Dictionary() {
2352  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IChronoStatSvc*)0x0)->GetClass();
2353  IChronoStatSvc_TClassManip(theClass);
2354  return theClass;
2355  }
2356 
2357  static void IChronoStatSvc_TClassManip(TClass* ){
2358  }
2359 
2360 } // end of namespace ROOT
2361 
2362 namespace ROOT {
2363  static TClass *IConverter_Dictionary();
2364  static void IConverter_TClassManip(TClass*);
2365  static void delete_IConverter(void *p);
2366  static void deleteArray_IConverter(void *p);
2367  static void destruct_IConverter(void *p);
2368 
2369  // Function generating the singleton type initializer
2370  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IConverter*)
2371  {
2372  ::IConverter *ptr = 0;
2373  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IConverter));
2374  static ::ROOT::TGenericClassInfo
2375  instance("IConverter", "GaudiKernel/IConverter.h", 58,
2376  typeid(::IConverter), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2377  &IConverter_Dictionary, isa_proxy, 4,
2378  sizeof(::IConverter) );
2379  instance.SetDelete(&delete_IConverter);
2380  instance.SetDeleteArray(&deleteArray_IConverter);
2381  instance.SetDestructor(&destruct_IConverter);
2382  return &instance;
2383  }
2384  TGenericClassInfo *GenerateInitInstance(const ::IConverter*)
2385  {
2386  return GenerateInitInstanceLocal((::IConverter*)0);
2387  }
2388  // Static variable to force the class initialization
2389  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IConverter*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2390 
2391  // Dictionary for non-ClassDef classes
2392  static TClass *IConverter_Dictionary() {
2393  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IConverter*)0x0)->GetClass();
2394  IConverter_TClassManip(theClass);
2395  return theClass;
2396  }
2397 
2398  static void IConverter_TClassManip(TClass* ){
2399  }
2400 
2401 } // end of namespace ROOT
2402 
2403 namespace ROOT {
2404  static TClass *IConversionSvc_Dictionary();
2405  static void IConversionSvc_TClassManip(TClass*);
2406  static void delete_IConversionSvc(void *p);
2407  static void deleteArray_IConversionSvc(void *p);
2408  static void destruct_IConversionSvc(void *p);
2409 
2410  // Function generating the singleton type initializer
2411  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IConversionSvc*)
2412  {
2413  ::IConversionSvc *ptr = 0;
2414  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IConversionSvc));
2415  static ::ROOT::TGenericClassInfo
2416  instance("IConversionSvc", "GaudiKernel/IConversionSvc.h", 37,
2417  typeid(::IConversionSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2418  &IConversionSvc_Dictionary, isa_proxy, 4,
2419  sizeof(::IConversionSvc) );
2420  instance.SetDelete(&delete_IConversionSvc);
2421  instance.SetDeleteArray(&deleteArray_IConversionSvc);
2422  instance.SetDestructor(&destruct_IConversionSvc);
2423  return &instance;
2424  }
2425  TGenericClassInfo *GenerateInitInstance(const ::IConversionSvc*)
2426  {
2427  return GenerateInitInstanceLocal((::IConversionSvc*)0);
2428  }
2429  // Static variable to force the class initialization
2430  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IConversionSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2431 
2432  // Dictionary for non-ClassDef classes
2433  static TClass *IConversionSvc_Dictionary() {
2434  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IConversionSvc*)0x0)->GetClass();
2435  IConversionSvc_TClassManip(theClass);
2436  return theClass;
2437  }
2438 
2439  static void IConversionSvc_TClassManip(TClass* ){
2440  }
2441 
2442 } // end of namespace ROOT
2443 
2444 namespace ROOT {
2445  static TClass *IExceptionSvc_Dictionary();
2446  static void IExceptionSvc_TClassManip(TClass*);
2447  static void delete_IExceptionSvc(void *p);
2448  static void deleteArray_IExceptionSvc(void *p);
2449  static void destruct_IExceptionSvc(void *p);
2450 
2451  // Function generating the singleton type initializer
2452  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IExceptionSvc*)
2453  {
2454  ::IExceptionSvc *ptr = 0;
2455  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IExceptionSvc));
2456  static ::ROOT::TGenericClassInfo
2457  instance("IExceptionSvc", "GaudiKernel/IExceptionSvc.h", 24,
2458  typeid(::IExceptionSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2459  &IExceptionSvc_Dictionary, isa_proxy, 4,
2460  sizeof(::IExceptionSvc) );
2461  instance.SetDelete(&delete_IExceptionSvc);
2462  instance.SetDeleteArray(&deleteArray_IExceptionSvc);
2463  instance.SetDestructor(&destruct_IExceptionSvc);
2464  return &instance;
2465  }
2466  TGenericClassInfo *GenerateInitInstance(const ::IExceptionSvc*)
2467  {
2468  return GenerateInitInstanceLocal((::IExceptionSvc*)0);
2469  }
2470  // Static variable to force the class initialization
2471  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IExceptionSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2472 
2473  // Dictionary for non-ClassDef classes
2474  static TClass *IExceptionSvc_Dictionary() {
2475  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IExceptionSvc*)0x0)->GetClass();
2476  IExceptionSvc_TClassManip(theClass);
2477  return theClass;
2478  }
2479 
2480  static void IExceptionSvc_TClassManip(TClass* ){
2481  }
2482 
2483 } // end of namespace ROOT
2484 
2485 namespace ROOT {
2486  static TClass *IHistogramSvc_Dictionary();
2487  static void IHistogramSvc_TClassManip(TClass*);
2488  static void delete_IHistogramSvc(void *p);
2489  static void deleteArray_IHistogramSvc(void *p);
2490  static void destruct_IHistogramSvc(void *p);
2491 
2492  // Function generating the singleton type initializer
2493  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IHistogramSvc*)
2494  {
2495  ::IHistogramSvc *ptr = 0;
2496  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IHistogramSvc));
2497  static ::ROOT::TGenericClassInfo
2498  instance("IHistogramSvc", "GaudiKernel/IHistogramSvc.h", 47,
2499  typeid(::IHistogramSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2500  &IHistogramSvc_Dictionary, isa_proxy, 4,
2501  sizeof(::IHistogramSvc) );
2502  instance.SetDelete(&delete_IHistogramSvc);
2503  instance.SetDeleteArray(&deleteArray_IHistogramSvc);
2504  instance.SetDestructor(&destruct_IHistogramSvc);
2505  return &instance;
2506  }
2507  TGenericClassInfo *GenerateInitInstance(const ::IHistogramSvc*)
2508  {
2509  return GenerateInitInstanceLocal((::IHistogramSvc*)0);
2510  }
2511  // Static variable to force the class initialization
2512  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IHistogramSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2513 
2514  // Dictionary for non-ClassDef classes
2515  static TClass *IHistogramSvc_Dictionary() {
2516  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IHistogramSvc*)0x0)->GetClass();
2517  IHistogramSvc_TClassManip(theClass);
2518  return theClass;
2519  }
2520 
2521  static void IHistogramSvc_TClassManip(TClass* ){
2522  }
2523 
2524 } // end of namespace ROOT
2525 
2526 namespace ROOT {
2527  static TClass *INTupleSvc_Dictionary();
2528  static void INTupleSvc_TClassManip(TClass*);
2529  static void delete_INTupleSvc(void *p);
2530  static void deleteArray_INTupleSvc(void *p);
2531  static void destruct_INTupleSvc(void *p);
2532 
2533  // Function generating the singleton type initializer
2534  static TGenericClassInfo *GenerateInitInstanceLocal(const ::INTupleSvc*)
2535  {
2536  ::INTupleSvc *ptr = 0;
2537  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::INTupleSvc));
2538  static ::ROOT::TGenericClassInfo
2539  instance("INTupleSvc", "GaudiKernel/INTupleSvc.h", 37,
2540  typeid(::INTupleSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2541  &INTupleSvc_Dictionary, isa_proxy, 4,
2542  sizeof(::INTupleSvc) );
2543  instance.SetDelete(&delete_INTupleSvc);
2544  instance.SetDeleteArray(&deleteArray_INTupleSvc);
2545  instance.SetDestructor(&destruct_INTupleSvc);
2546  return &instance;
2547  }
2548  TGenericClassInfo *GenerateInitInstance(const ::INTupleSvc*)
2549  {
2550  return GenerateInitInstanceLocal((::INTupleSvc*)0);
2551  }
2552  // Static variable to force the class initialization
2553  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::INTupleSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2554 
2555  // Dictionary for non-ClassDef classes
2556  static TClass *INTupleSvc_Dictionary() {
2557  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::INTupleSvc*)0x0)->GetClass();
2558  INTupleSvc_TClassManip(theClass);
2559  return theClass;
2560  }
2561 
2562  static void INTupleSvc_TClassManip(TClass* ){
2563  }
2564 
2565 } // end of namespace ROOT
2566 
2567 namespace ROOT {
2568  static TClass *IRndmGen_Dictionary();
2569  static void IRndmGen_TClassManip(TClass*);
2570  static void delete_IRndmGen(void *p);
2571  static void deleteArray_IRndmGen(void *p);
2572  static void destruct_IRndmGen(void *p);
2573 
2574  // Function generating the singleton type initializer
2575  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IRndmGen*)
2576  {
2577  ::IRndmGen *ptr = 0;
2578  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IRndmGen));
2579  static ::ROOT::TGenericClassInfo
2580  instance("IRndmGen", "GaudiKernel/IRndmGen.h", 34,
2581  typeid(::IRndmGen), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2582  &IRndmGen_Dictionary, isa_proxy, 4,
2583  sizeof(::IRndmGen) );
2584  instance.SetDelete(&delete_IRndmGen);
2585  instance.SetDeleteArray(&deleteArray_IRndmGen);
2586  instance.SetDestructor(&destruct_IRndmGen);
2587  return &instance;
2588  }
2589  TGenericClassInfo *GenerateInitInstance(const ::IRndmGen*)
2590  {
2591  return GenerateInitInstanceLocal((::IRndmGen*)0);
2592  }
2593  // Static variable to force the class initialization
2594  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IRndmGen*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2595 
2596  // Dictionary for non-ClassDef classes
2597  static TClass *IRndmGen_Dictionary() {
2598  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IRndmGen*)0x0)->GetClass();
2599  IRndmGen_TClassManip(theClass);
2600  return theClass;
2601  }
2602 
2603  static void IRndmGen_TClassManip(TClass* ){
2604  }
2605 
2606 } // end of namespace ROOT
2607 
2608 namespace ROOT {
2609  static TClass *IRndmGencLcLParam_Dictionary();
2610  static void IRndmGencLcLParam_TClassManip(TClass*);
2611  static void delete_IRndmGencLcLParam(void *p);
2612  static void deleteArray_IRndmGencLcLParam(void *p);
2613  static void destruct_IRndmGencLcLParam(void *p);
2614 
2615  // Function generating the singleton type initializer
2616  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IRndmGen::Param*)
2617  {
2618  ::IRndmGen::Param *ptr = 0;
2619  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IRndmGen::Param));
2620  static ::ROOT::TGenericClassInfo
2621  instance("IRndmGen::Param", "GaudiKernel/IRndmGen.h", 40,
2622  typeid(::IRndmGen::Param), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2623  &IRndmGencLcLParam_Dictionary, isa_proxy, 4,
2624  sizeof(::IRndmGen::Param) );
2625  instance.SetDelete(&delete_IRndmGencLcLParam);
2626  instance.SetDeleteArray(&deleteArray_IRndmGencLcLParam);
2627  instance.SetDestructor(&destruct_IRndmGencLcLParam);
2628  return &instance;
2629  }
2630  TGenericClassInfo *GenerateInitInstance(const ::IRndmGen::Param*)
2631  {
2632  return GenerateInitInstanceLocal((::IRndmGen::Param*)0);
2633  }
2634  // Static variable to force the class initialization
2635  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IRndmGen::Param*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2636 
2637  // Dictionary for non-ClassDef classes
2638  static TClass *IRndmGencLcLParam_Dictionary() {
2639  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IRndmGen::Param*)0x0)->GetClass();
2640  IRndmGencLcLParam_TClassManip(theClass);
2641  return theClass;
2642  }
2643 
2644  static void IRndmGencLcLParam_TClassManip(TClass* ){
2645  }
2646 
2647 } // end of namespace ROOT
2648 
2649 namespace ROOT {
2650  static TClass *IRndmGenSvc_Dictionary();
2651  static void IRndmGenSvc_TClassManip(TClass*);
2652  static void delete_IRndmGenSvc(void *p);
2653  static void deleteArray_IRndmGenSvc(void *p);
2654  static void destruct_IRndmGenSvc(void *p);
2655 
2656  // Function generating the singleton type initializer
2657  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IRndmGenSvc*)
2658  {
2659  ::IRndmGenSvc *ptr = 0;
2660  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IRndmGenSvc));
2661  static ::ROOT::TGenericClassInfo
2662  instance("IRndmGenSvc", "GaudiKernel/IRndmGenSvc.h", 35,
2663  typeid(::IRndmGenSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2664  &IRndmGenSvc_Dictionary, isa_proxy, 4,
2665  sizeof(::IRndmGenSvc) );
2666  instance.SetDelete(&delete_IRndmGenSvc);
2667  instance.SetDeleteArray(&deleteArray_IRndmGenSvc);
2668  instance.SetDestructor(&destruct_IRndmGenSvc);
2669  return &instance;
2670  }
2671  TGenericClassInfo *GenerateInitInstance(const ::IRndmGenSvc*)
2672  {
2673  return GenerateInitInstanceLocal((::IRndmGenSvc*)0);
2674  }
2675  // Static variable to force the class initialization
2676  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IRndmGenSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2677 
2678  // Dictionary for non-ClassDef classes
2679  static TClass *IRndmGenSvc_Dictionary() {
2680  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IRndmGenSvc*)0x0)->GetClass();
2681  IRndmGenSvc_TClassManip(theClass);
2682  return theClass;
2683  }
2684 
2685  static void IRndmGenSvc_TClassManip(TClass* ){
2686  }
2687 
2688 } // end of namespace ROOT
2689 
2690 namespace ROOT {
2691  static TClass *Algorithm_Dictionary();
2692  static void Algorithm_TClassManip(TClass*);
2693  static void delete_Algorithm(void *p);
2694  static void deleteArray_Algorithm(void *p);
2695  static void destruct_Algorithm(void *p);
2696 
2697  // Function generating the singleton type initializer
2698  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Algorithm*)
2699  {
2700  ::Algorithm *ptr = 0;
2701  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Algorithm));
2702  static ::ROOT::TGenericClassInfo
2703  instance("Algorithm", "GaudiKernel/Algorithm.h", 79,
2704  typeid(::Algorithm), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2705  &Algorithm_Dictionary, isa_proxy, 4,
2706  sizeof(::Algorithm) );
2707  instance.SetDelete(&delete_Algorithm);
2708  instance.SetDeleteArray(&deleteArray_Algorithm);
2709  instance.SetDestructor(&destruct_Algorithm);
2710  return &instance;
2711  }
2712  TGenericClassInfo *GenerateInitInstance(const ::Algorithm*)
2713  {
2714  return GenerateInitInstanceLocal((::Algorithm*)0);
2715  }
2716  // Static variable to force the class initialization
2717  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Algorithm*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2718 
2719  // Dictionary for non-ClassDef classes
2720  static TClass *Algorithm_Dictionary() {
2721  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Algorithm*)0x0)->GetClass();
2722  Algorithm_TClassManip(theClass);
2723  return theClass;
2724  }
2725 
2726  static void Algorithm_TClassManip(TClass* ){
2727  }
2728 
2729 } // end of namespace ROOT
2730 
2731 namespace ROOT {
2732  static TClass *DataObject_Dictionary();
2733  static void DataObject_TClassManip(TClass*);
2734  static void *new_DataObject(void *p = 0);
2735  static void *newArray_DataObject(Long_t size, void *p);
2736  static void delete_DataObject(void *p);
2737  static void deleteArray_DataObject(void *p);
2738  static void destruct_DataObject(void *p);
2739 
2740  // Function generating the singleton type initializer
2741  static TGenericClassInfo *GenerateInitInstanceLocal(const ::DataObject*)
2742  {
2743  ::DataObject *ptr = 0;
2744  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::DataObject));
2745  static ::ROOT::TGenericClassInfo
2746  instance("DataObject", "GaudiKernel/DataObject.h", 30,
2747  typeid(::DataObject), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2748  &DataObject_Dictionary, isa_proxy, 4,
2749  sizeof(::DataObject) );
2750  instance.SetNew(&new_DataObject);
2751  instance.SetNewArray(&newArray_DataObject);
2752  instance.SetDelete(&delete_DataObject);
2753  instance.SetDeleteArray(&deleteArray_DataObject);
2754  instance.SetDestructor(&destruct_DataObject);
2755  return &instance;
2756  }
2757  TGenericClassInfo *GenerateInitInstance(const ::DataObject*)
2758  {
2759  return GenerateInitInstanceLocal((::DataObject*)0);
2760  }
2761  // Static variable to force the class initialization
2762  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DataObject*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2763 
2764  // Dictionary for non-ClassDef classes
2765  static TClass *DataObject_Dictionary() {
2766  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::DataObject*)0x0)->GetClass();
2767  DataObject_TClassManip(theClass);
2768  return theClass;
2769  }
2770 
2771  static void DataObject_TClassManip(TClass* theClass){
2772  theClass->CreateAttributeMap();
2773  TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
2774  attrMap->AddProperty("id","00000001-0000-0000-0000-000000000000");
2775  }
2776 
2777 } // end of namespace ROOT
2778 
2779 namespace ROOT {
2780  static TClass *ObjectContainerBase_Dictionary();
2781  static void ObjectContainerBase_TClassManip(TClass*);
2782  static void delete_ObjectContainerBase(void *p);
2783  static void deleteArray_ObjectContainerBase(void *p);
2784  static void destruct_ObjectContainerBase(void *p);
2785 
2786  // Function generating the singleton type initializer
2787  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ObjectContainerBase*)
2788  {
2789  ::ObjectContainerBase *ptr = 0;
2790  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ObjectContainerBase));
2791  static ::ROOT::TGenericClassInfo
2792  instance("ObjectContainerBase", "GaudiKernel/ObjectContainerBase.h", 19,
2793  typeid(::ObjectContainerBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2794  &ObjectContainerBase_Dictionary, isa_proxy, 4,
2795  sizeof(::ObjectContainerBase) );
2796  instance.SetDelete(&delete_ObjectContainerBase);
2797  instance.SetDeleteArray(&deleteArray_ObjectContainerBase);
2798  instance.SetDestructor(&destruct_ObjectContainerBase);
2799  return &instance;
2800  }
2801  TGenericClassInfo *GenerateInitInstance(const ::ObjectContainerBase*)
2802  {
2803  return GenerateInitInstanceLocal((::ObjectContainerBase*)0);
2804  }
2805  // Static variable to force the class initialization
2806  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ObjectContainerBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2807 
2808  // Dictionary for non-ClassDef classes
2809  static TClass *ObjectContainerBase_Dictionary() {
2810  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ObjectContainerBase*)0x0)->GetClass();
2811  ObjectContainerBase_TClassManip(theClass);
2812  return theClass;
2813  }
2814 
2815  static void ObjectContainerBase_TClassManip(TClass* ){
2816  }
2817 
2818 } // end of namespace ROOT
2819 
2820 namespace ROOT {
2821  static TClass *ContainedObject_Dictionary();
2822  static void ContainedObject_TClassManip(TClass*);
2823 
2824  // Function generating the singleton type initializer
2825  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ContainedObject*)
2826  {
2827  ::ContainedObject *ptr = 0;
2828  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ContainedObject));
2829  static ::ROOT::TGenericClassInfo
2830  instance("ContainedObject", "GaudiKernel/ContainedObject.h", 31,
2831  typeid(::ContainedObject), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2832  &ContainedObject_Dictionary, isa_proxy, 4,
2833  sizeof(::ContainedObject) );
2834  return &instance;
2835  }
2836  TGenericClassInfo *GenerateInitInstance(const ::ContainedObject*)
2837  {
2838  return GenerateInitInstanceLocal((::ContainedObject*)0);
2839  }
2840  // Static variable to force the class initialization
2841  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ContainedObject*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2842 
2843  // Dictionary for non-ClassDef classes
2844  static TClass *ContainedObject_Dictionary() {
2845  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ContainedObject*)0x0)->GetClass();
2846  ContainedObject_TClassManip(theClass);
2847  return theClass;
2848  }
2849 
2850  static void ContainedObject_TClassManip(TClass* theClass){
2851  theClass->CreateAttributeMap();
2852  TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
2853  attrMap->AddProperty("id","000000BE-0000-0000-0000-000000000000");
2854  }
2855 
2856 } // end of namespace ROOT
2857 
2858 namespace ROOT {
2859  static TClass *IDataStreamTool_Dictionary();
2860  static void IDataStreamTool_TClassManip(TClass*);
2861  static void delete_IDataStreamTool(void *p);
2862  static void deleteArray_IDataStreamTool(void *p);
2863  static void destruct_IDataStreamTool(void *p);
2864 
2865  // Function generating the singleton type initializer
2866  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDataStreamTool*)
2867  {
2868  ::IDataStreamTool *ptr = 0;
2869  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDataStreamTool));
2870  static ::ROOT::TGenericClassInfo
2871  instance("IDataStreamTool", "GaudiKernel/IDataStreamTool.h", 22,
2872  typeid(::IDataStreamTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2873  &IDataStreamTool_Dictionary, isa_proxy, 4,
2874  sizeof(::IDataStreamTool) );
2875  instance.SetDelete(&delete_IDataStreamTool);
2876  instance.SetDeleteArray(&deleteArray_IDataStreamTool);
2877  instance.SetDestructor(&destruct_IDataStreamTool);
2878  return &instance;
2879  }
2880  TGenericClassInfo *GenerateInitInstance(const ::IDataStreamTool*)
2881  {
2882  return GenerateInitInstanceLocal((::IDataStreamTool*)0);
2883  }
2884  // Static variable to force the class initialization
2885  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDataStreamTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2886 
2887  // Dictionary for non-ClassDef classes
2888  static TClass *IDataStreamTool_Dictionary() {
2889  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDataStreamTool*)0x0)->GetClass();
2890  IDataStreamTool_TClassManip(theClass);
2891  return theClass;
2892  }
2893 
2894  static void IDataStreamTool_TClassManip(TClass* ){
2895  }
2896 
2897 } // end of namespace ROOT
2898 
2899 namespace ROOT {
2900  static TClass *IOpaqueAddress_Dictionary();
2901  static void IOpaqueAddress_TClassManip(TClass*);
2902  static void delete_IOpaqueAddress(void *p);
2903  static void deleteArray_IOpaqueAddress(void *p);
2904  static void destruct_IOpaqueAddress(void *p);
2905 
2906  // Function generating the singleton type initializer
2907  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IOpaqueAddress*)
2908  {
2909  ::IOpaqueAddress *ptr = 0;
2910  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IOpaqueAddress));
2911  static ::ROOT::TGenericClassInfo
2912  instance("IOpaqueAddress", "GaudiKernel/IOpaqueAddress.h", 23,
2913  typeid(::IOpaqueAddress), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2914  &IOpaqueAddress_Dictionary, isa_proxy, 4,
2915  sizeof(::IOpaqueAddress) );
2916  instance.SetDelete(&delete_IOpaqueAddress);
2917  instance.SetDeleteArray(&deleteArray_IOpaqueAddress);
2918  instance.SetDestructor(&destruct_IOpaqueAddress);
2919  return &instance;
2920  }
2921  TGenericClassInfo *GenerateInitInstance(const ::IOpaqueAddress*)
2922  {
2923  return GenerateInitInstanceLocal((::IOpaqueAddress*)0);
2924  }
2925  // Static variable to force the class initialization
2926  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IOpaqueAddress*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2927 
2928  // Dictionary for non-ClassDef classes
2929  static TClass *IOpaqueAddress_Dictionary() {
2930  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IOpaqueAddress*)0x0)->GetClass();
2931  IOpaqueAddress_TClassManip(theClass);
2932  return theClass;
2933  }
2934 
2935  static void IOpaqueAddress_TClassManip(TClass* ){
2936  }
2937 
2938 } // end of namespace ROOT
2939 
2940 namespace ROOT {
2941  static TClass *IEvtSelector_Dictionary();
2942  static void IEvtSelector_TClassManip(TClass*);
2943  static void delete_IEvtSelector(void *p);
2944  static void deleteArray_IEvtSelector(void *p);
2945  static void destruct_IEvtSelector(void *p);
2946 
2947  // Function generating the singleton type initializer
2948  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IEvtSelector*)
2949  {
2950  ::IEvtSelector *ptr = 0;
2951  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IEvtSelector));
2952  static ::ROOT::TGenericClassInfo
2953  instance("IEvtSelector", "GaudiKernel/IEvtSelector.h", 18,
2954  typeid(::IEvtSelector), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2955  &IEvtSelector_Dictionary, isa_proxy, 4,
2956  sizeof(::IEvtSelector) );
2957  instance.SetDelete(&delete_IEvtSelector);
2958  instance.SetDeleteArray(&deleteArray_IEvtSelector);
2959  instance.SetDestructor(&destruct_IEvtSelector);
2960  return &instance;
2961  }
2962  TGenericClassInfo *GenerateInitInstance(const ::IEvtSelector*)
2963  {
2964  return GenerateInitInstanceLocal((::IEvtSelector*)0);
2965  }
2966  // Static variable to force the class initialization
2967  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IEvtSelector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2968 
2969  // Dictionary for non-ClassDef classes
2970  static TClass *IEvtSelector_Dictionary() {
2971  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IEvtSelector*)0x0)->GetClass();
2972  IEvtSelector_TClassManip(theClass);
2973  return theClass;
2974  }
2975 
2976  static void IEvtSelector_TClassManip(TClass* ){
2977  }
2978 
2979 } // end of namespace ROOT
2980 
2981 namespace ROOT {
2982  static TClass *Incident_Dictionary();
2983  static void Incident_TClassManip(TClass*);
2984  static void delete_Incident(void *p);
2985  static void deleteArray_Incident(void *p);
2986  static void destruct_Incident(void *p);
2987 
2988  // Function generating the singleton type initializer
2989  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Incident*)
2990  {
2991  ::Incident *ptr = 0;
2992  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Incident));
2993  static ::ROOT::TGenericClassInfo
2994  instance("Incident", "GaudiKernel/Incident.h", 17,
2995  typeid(::Incident), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2996  &Incident_Dictionary, isa_proxy, 4,
2997  sizeof(::Incident) );
2998  instance.SetDelete(&delete_Incident);
2999  instance.SetDeleteArray(&deleteArray_Incident);
3000  instance.SetDestructor(&destruct_Incident);
3001  return &instance;
3002  }
3003  TGenericClassInfo *GenerateInitInstance(const ::Incident*)
3004  {
3005  return GenerateInitInstanceLocal((::Incident*)0);
3006  }
3007  // Static variable to force the class initialization
3008  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Incident*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3009 
3010  // Dictionary for non-ClassDef classes
3011  static TClass *Incident_Dictionary() {
3012  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Incident*)0x0)->GetClass();
3013  Incident_TClassManip(theClass);
3014  return theClass;
3015  }
3016 
3017  static void Incident_TClassManip(TClass* ){
3018  }
3019 
3020 } // end of namespace ROOT
3021 
3022 namespace ROOT {
3023  static TClass *IIncidentSvc_Dictionary();
3024  static void IIncidentSvc_TClassManip(TClass*);
3025  static void delete_IIncidentSvc(void *p);
3026  static void deleteArray_IIncidentSvc(void *p);
3027  static void destruct_IIncidentSvc(void *p);
3028 
3029  // Function generating the singleton type initializer
3030  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IIncidentSvc*)
3031  {
3032  ::IIncidentSvc *ptr = 0;
3033  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IIncidentSvc));
3034  static ::ROOT::TGenericClassInfo
3035  instance("IIncidentSvc", "GaudiKernel/IIncidentSvc.h", 23,
3036  typeid(::IIncidentSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3037  &IIncidentSvc_Dictionary, isa_proxy, 4,
3038  sizeof(::IIncidentSvc) );
3039  instance.SetDelete(&delete_IIncidentSvc);
3040  instance.SetDeleteArray(&deleteArray_IIncidentSvc);
3041  instance.SetDestructor(&destruct_IIncidentSvc);
3042  return &instance;
3043  }
3044  TGenericClassInfo *GenerateInitInstance(const ::IIncidentSvc*)
3045  {
3046  return GenerateInitInstanceLocal((::IIncidentSvc*)0);
3047  }
3048  // Static variable to force the class initialization
3049  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IIncidentSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3050 
3051  // Dictionary for non-ClassDef classes
3052  static TClass *IIncidentSvc_Dictionary() {
3053  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IIncidentSvc*)0x0)->GetClass();
3054  IIncidentSvc_TClassManip(theClass);
3055  return theClass;
3056  }
3057 
3058  static void IIncidentSvc_TClassManip(TClass* ){
3059  }
3060 
3061 } // end of namespace ROOT
3062 
3063 namespace ROOT {
3064  static TClass *Service_Dictionary();
3065  static void Service_TClassManip(TClass*);
3066 
3067  // Function generating the singleton type initializer
3068  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Service*)
3069  {
3070  ::Service *ptr = 0;
3071  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Service));
3072  static ::ROOT::TGenericClassInfo
3073  instance("Service", "GaudiKernel/Service.h", 36,
3074  typeid(::Service), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3075  &Service_Dictionary, isa_proxy, 4,
3076  sizeof(::Service) );
3077  return &instance;
3078  }
3079  TGenericClassInfo *GenerateInitInstance(const ::Service*)
3080  {
3081  return GenerateInitInstanceLocal((::Service*)0);
3082  }
3083  // Static variable to force the class initialization
3084  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Service*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3085 
3086  // Dictionary for non-ClassDef classes
3087  static TClass *Service_Dictionary() {
3088  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Service*)0x0)->GetClass();
3089  Service_TClassManip(theClass);
3090  return theClass;
3091  }
3092 
3093  static void Service_TClassManip(TClass* ){
3094  }
3095 
3096 } // end of namespace ROOT
3097 
3098 namespace ROOT {
3099  static TClass *GenericAddress_Dictionary();
3100  static void GenericAddress_TClassManip(TClass*);
3101  static void *new_GenericAddress(void *p = 0);
3102  static void *newArray_GenericAddress(Long_t size, void *p);
3103  static void delete_GenericAddress(void *p);
3104  static void deleteArray_GenericAddress(void *p);
3105  static void destruct_GenericAddress(void *p);
3106 
3107  // Function generating the singleton type initializer
3108  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GenericAddress*)
3109  {
3110  ::GenericAddress *ptr = 0;
3111  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GenericAddress));
3112  static ::ROOT::TGenericClassInfo
3113  instance("GenericAddress", "GaudiKernel/GenericAddress.h", 20,
3114  typeid(::GenericAddress), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3115  &GenericAddress_Dictionary, isa_proxy, 4,
3116  sizeof(::GenericAddress) );
3117  instance.SetNew(&new_GenericAddress);
3118  instance.SetNewArray(&newArray_GenericAddress);
3119  instance.SetDelete(&delete_GenericAddress);
3120  instance.SetDeleteArray(&deleteArray_GenericAddress);
3121  instance.SetDestructor(&destruct_GenericAddress);
3122  return &instance;
3123  }
3124  TGenericClassInfo *GenerateInitInstance(const ::GenericAddress*)
3125  {
3126  return GenerateInitInstanceLocal((::GenericAddress*)0);
3127  }
3128  // Static variable to force the class initialization
3129  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GenericAddress*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3130 
3131  // Dictionary for non-ClassDef classes
3132  static TClass *GenericAddress_Dictionary() {
3133  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GenericAddress*)0x0)->GetClass();
3134  GenericAddress_TClassManip(theClass);
3135  return theClass;
3136  }
3137 
3138  static void GenericAddress_TClassManip(TClass* ){
3139  }
3140 
3141 } // end of namespace ROOT
3142 
3143 namespace ROOT {
3144  static TClass *KeyedObjectlEintgR_Dictionary();
3145  static void KeyedObjectlEintgR_TClassManip(TClass*);
3146  static void *new_KeyedObjectlEintgR(void *p = 0);
3147  static void *newArray_KeyedObjectlEintgR(Long_t size, void *p);
3148  static void delete_KeyedObjectlEintgR(void *p);
3149  static void deleteArray_KeyedObjectlEintgR(void *p);
3150  static void destruct_KeyedObjectlEintgR(void *p);
3151 
3152  // Function generating the singleton type initializer
3153  static TGenericClassInfo *GenerateInitInstanceLocal(const ::KeyedObject<int>*)
3154  {
3155  ::KeyedObject<int> *ptr = 0;
3156  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::KeyedObject<int>));
3157  static ::ROOT::TGenericClassInfo
3158  instance("KeyedObject<int>", "GaudiKernel/KeyedObject.h", 30,
3159  typeid(::KeyedObject<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3160  &KeyedObjectlEintgR_Dictionary, isa_proxy, 4,
3161  sizeof(::KeyedObject<int>) );
3162  instance.SetNew(&new_KeyedObjectlEintgR);
3163  instance.SetNewArray(&newArray_KeyedObjectlEintgR);
3164  instance.SetDelete(&delete_KeyedObjectlEintgR);
3165  instance.SetDeleteArray(&deleteArray_KeyedObjectlEintgR);
3166  instance.SetDestructor(&destruct_KeyedObjectlEintgR);
3167  return &instance;
3168  }
3169  TGenericClassInfo *GenerateInitInstance(const ::KeyedObject<int>*)
3170  {
3171  return GenerateInitInstanceLocal((::KeyedObject<int>*)0);
3172  }
3173  // Static variable to force the class initialization
3174  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::KeyedObject<int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3175 
3176  // Dictionary for non-ClassDef classes
3177  static TClass *KeyedObjectlEintgR_Dictionary() {
3178  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::KeyedObject<int>*)0x0)->GetClass();
3179  KeyedObjectlEintgR_TClassManip(theClass);
3180  return theClass;
3181  }
3182 
3183  static void KeyedObjectlEintgR_TClassManip(TClass* ){
3184  }
3185 
3186 } // end of namespace ROOT
3187 
3188 namespace ROOT {
3189  static TClass *KeyedObjectlEunsignedsPintgR_Dictionary();
3190  static void KeyedObjectlEunsignedsPintgR_TClassManip(TClass*);
3191  static void *new_KeyedObjectlEunsignedsPintgR(void *p = 0);
3192  static void *newArray_KeyedObjectlEunsignedsPintgR(Long_t size, void *p);
3193  static void delete_KeyedObjectlEunsignedsPintgR(void *p);
3194  static void deleteArray_KeyedObjectlEunsignedsPintgR(void *p);
3195  static void destruct_KeyedObjectlEunsignedsPintgR(void *p);
3196 
3197  // Function generating the singleton type initializer
3198  static TGenericClassInfo *GenerateInitInstanceLocal(const ::KeyedObject<unsigned int>*)
3199  {
3200  ::KeyedObject<unsigned int> *ptr = 0;
3201  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::KeyedObject<unsigned int>));
3202  static ::ROOT::TGenericClassInfo
3203  instance("KeyedObject<unsigned int>", "GaudiKernel/KeyedObject.h", 30,
3204  typeid(::KeyedObject<unsigned int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3205  &KeyedObjectlEunsignedsPintgR_Dictionary, isa_proxy, 4,
3206  sizeof(::KeyedObject<unsigned int>) );
3207  instance.SetNew(&new_KeyedObjectlEunsignedsPintgR);
3208  instance.SetNewArray(&newArray_KeyedObjectlEunsignedsPintgR);
3209  instance.SetDelete(&delete_KeyedObjectlEunsignedsPintgR);
3210  instance.SetDeleteArray(&deleteArray_KeyedObjectlEunsignedsPintgR);
3211  instance.SetDestructor(&destruct_KeyedObjectlEunsignedsPintgR);
3212  return &instance;
3213  }
3214  TGenericClassInfo *GenerateInitInstance(const ::KeyedObject<unsigned int>*)
3215  {
3216  return GenerateInitInstanceLocal((::KeyedObject<unsigned int>*)0);
3217  }
3218  // Static variable to force the class initialization
3219  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::KeyedObject<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3220 
3221  // Dictionary for non-ClassDef classes
3222  static TClass *KeyedObjectlEunsignedsPintgR_Dictionary() {
3223  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::KeyedObject<unsigned int>*)0x0)->GetClass();
3224  KeyedObjectlEunsignedsPintgR_TClassManip(theClass);
3225  return theClass;
3226  }
3227 
3228  static void KeyedObjectlEunsignedsPintgR_TClassManip(TClass* ){
3229  }
3230 
3231 } // end of namespace ROOT
3232 
3233 namespace ROOT {
3234  static TClass *KeyedObjectlElonggR_Dictionary();
3235  static void KeyedObjectlElonggR_TClassManip(TClass*);
3236  static void *new_KeyedObjectlElonggR(void *p = 0);
3237  static void *newArray_KeyedObjectlElonggR(Long_t size, void *p);
3238  static void delete_KeyedObjectlElonggR(void *p);
3239  static void deleteArray_KeyedObjectlElonggR(void *p);
3240  static void destruct_KeyedObjectlElonggR(void *p);
3241 
3242  // Function generating the singleton type initializer
3243  static TGenericClassInfo *GenerateInitInstanceLocal(const ::KeyedObject<long>*)
3244  {
3245  ::KeyedObject<long> *ptr = 0;
3246  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::KeyedObject<long>));
3247  static ::ROOT::TGenericClassInfo
3248  instance("KeyedObject<long>", "GaudiKernel/KeyedObject.h", 30,
3249  typeid(::KeyedObject<long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3250  &KeyedObjectlElonggR_Dictionary, isa_proxy, 4,
3251  sizeof(::KeyedObject<long>) );
3252  instance.SetNew(&new_KeyedObjectlElonggR);
3253  instance.SetNewArray(&newArray_KeyedObjectlElonggR);
3254  instance.SetDelete(&delete_KeyedObjectlElonggR);
3255  instance.SetDeleteArray(&deleteArray_KeyedObjectlElonggR);
3256  instance.SetDestructor(&destruct_KeyedObjectlElonggR);
3257  return &instance;
3258  }
3259  TGenericClassInfo *GenerateInitInstance(const ::KeyedObject<long>*)
3260  {
3261  return GenerateInitInstanceLocal((::KeyedObject<long>*)0);
3262  }
3263  // Static variable to force the class initialization
3264  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::KeyedObject<long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3265 
3266  // Dictionary for non-ClassDef classes
3267  static TClass *KeyedObjectlElonggR_Dictionary() {
3268  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::KeyedObject<long>*)0x0)->GetClass();
3269  KeyedObjectlElonggR_TClassManip(theClass);
3270  return theClass;
3271  }
3272 
3273  static void KeyedObjectlElonggR_TClassManip(TClass* ){
3274  }
3275 
3276 } // end of namespace ROOT
3277 
3278 namespace ROOT {
3279  static TClass *KeyedObjectlEunsignedsPlonggR_Dictionary();
3280  static void KeyedObjectlEunsignedsPlonggR_TClassManip(TClass*);
3281  static void *new_KeyedObjectlEunsignedsPlonggR(void *p = 0);
3282  static void *newArray_KeyedObjectlEunsignedsPlonggR(Long_t size, void *p);
3283  static void delete_KeyedObjectlEunsignedsPlonggR(void *p);
3284  static void deleteArray_KeyedObjectlEunsignedsPlonggR(void *p);
3285  static void destruct_KeyedObjectlEunsignedsPlonggR(void *p);
3286 
3287  // Function generating the singleton type initializer
3288  static TGenericClassInfo *GenerateInitInstanceLocal(const ::KeyedObject<unsigned long>*)
3289  {
3290  ::KeyedObject<unsigned long> *ptr = 0;
3291  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::KeyedObject<unsigned long>));
3292  static ::ROOT::TGenericClassInfo
3293  instance("KeyedObject<unsigned long>", "GaudiKernel/KeyedObject.h", 30,
3294  typeid(::KeyedObject<unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3295  &KeyedObjectlEunsignedsPlonggR_Dictionary, isa_proxy, 4,
3296  sizeof(::KeyedObject<unsigned long>) );
3297  instance.SetNew(&new_KeyedObjectlEunsignedsPlonggR);
3298  instance.SetNewArray(&newArray_KeyedObjectlEunsignedsPlonggR);
3299  instance.SetDelete(&delete_KeyedObjectlEunsignedsPlonggR);
3300  instance.SetDeleteArray(&deleteArray_KeyedObjectlEunsignedsPlonggR);
3301  instance.SetDestructor(&destruct_KeyedObjectlEunsignedsPlonggR);
3302  return &instance;
3303  }
3304  TGenericClassInfo *GenerateInitInstance(const ::KeyedObject<unsigned long>*)
3305  {
3306  return GenerateInitInstanceLocal((::KeyedObject<unsigned long>*)0);
3307  }
3308  // Static variable to force the class initialization
3309  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::KeyedObject<unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3310 
3311  // Dictionary for non-ClassDef classes
3312  static TClass *KeyedObjectlEunsignedsPlonggR_Dictionary() {
3313  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::KeyedObject<unsigned long>*)0x0)->GetClass();
3314  KeyedObjectlEunsignedsPlonggR_TClassManip(theClass);
3315  return theClass;
3316  }
3317 
3318  static void KeyedObjectlEunsignedsPlonggR_TClassManip(TClass* ){
3319  }
3320 
3321 } // end of namespace ROOT
3322 
3323 namespace ROOT {
3324  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR_Dictionary();
3325  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR_TClassManip(TClass*);
3326  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p = 0);
3327  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(Long_t size, void *p);
3328  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p);
3329  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p);
3330  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p);
3331 
3332  // Function generating the singleton type initializer
3333  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Containers::KeyedObjectManager<Containers::map>*)
3334  {
3335  ::Containers::KeyedObjectManager<Containers::map> *ptr = 0;
3336  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Containers::KeyedObjectManager<Containers::map>));
3337  static ::ROOT::TGenericClassInfo
3338  instance("Containers::KeyedObjectManager<Containers::map>", "GaudiKernel/KeyedObjectManager.h", 46,
3339  typeid(::Containers::KeyedObjectManager<Containers::map>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3340  &ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR_Dictionary, isa_proxy, 4,
3341  sizeof(::Containers::KeyedObjectManager<Containers::map>) );
3342  instance.SetNew(&new_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR);
3343  instance.SetNewArray(&newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR);
3344  instance.SetDelete(&delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR);
3345  instance.SetDeleteArray(&deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR);
3346  instance.SetDestructor(&destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR);
3347  return &instance;
3348  }
3349  TGenericClassInfo *GenerateInitInstance(const ::Containers::KeyedObjectManager<Containers::map>*)
3350  {
3351  return GenerateInitInstanceLocal((::Containers::KeyedObjectManager<Containers::map>*)0);
3352  }
3353  // Static variable to force the class initialization
3354  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::map>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3355 
3356  // Dictionary for non-ClassDef classes
3357  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR_Dictionary() {
3358  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::map>*)0x0)->GetClass();
3359  ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR_TClassManip(theClass);
3360  return theClass;
3361  }
3362 
3363  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR_TClassManip(TClass* ){
3364  }
3365 
3366 } // end of namespace ROOT
3367 
3368 namespace ROOT {
3369  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR_Dictionary();
3370  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR_TClassManip(TClass*);
3371  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p = 0);
3372  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(Long_t size, void *p);
3373  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p);
3374  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p);
3375  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p);
3376 
3377  // Function generating the singleton type initializer
3378  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Containers::KeyedObjectManager<Containers::hashmap>*)
3379  {
3380  ::Containers::KeyedObjectManager<Containers::hashmap> *ptr = 0;
3381  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Containers::KeyedObjectManager<Containers::hashmap>));
3382  static ::ROOT::TGenericClassInfo
3383  instance("Containers::KeyedObjectManager<Containers::hashmap>", "GaudiKernel/KeyedObjectManager.h", 46,
3384  typeid(::Containers::KeyedObjectManager<Containers::hashmap>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3385  &ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR_Dictionary, isa_proxy, 4,
3386  sizeof(::Containers::KeyedObjectManager<Containers::hashmap>) );
3387  instance.SetNew(&new_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR);
3388  instance.SetNewArray(&newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR);
3389  instance.SetDelete(&delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR);
3390  instance.SetDeleteArray(&deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR);
3391  instance.SetDestructor(&destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR);
3392  return &instance;
3393  }
3394  TGenericClassInfo *GenerateInitInstance(const ::Containers::KeyedObjectManager<Containers::hashmap>*)
3395  {
3396  return GenerateInitInstanceLocal((::Containers::KeyedObjectManager<Containers::hashmap>*)0);
3397  }
3398  // Static variable to force the class initialization
3399  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::hashmap>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3400 
3401  // Dictionary for non-ClassDef classes
3402  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR_Dictionary() {
3403  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::hashmap>*)0x0)->GetClass();
3404  ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR_TClassManip(theClass);
3405  return theClass;
3406  }
3407 
3408  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR_TClassManip(TClass* ){
3409  }
3410 
3411 } // end of namespace ROOT
3412 
3413 namespace ROOT {
3414  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR_Dictionary();
3415  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR_TClassManip(TClass*);
3416  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p = 0);
3417  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(Long_t size, void *p);
3418  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p);
3419  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p);
3420  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p);
3421 
3422  // Function generating the singleton type initializer
3423  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Containers::KeyedObjectManager<Containers::vector>*)
3424  {
3425  ::Containers::KeyedObjectManager<Containers::vector> *ptr = 0;
3426  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Containers::KeyedObjectManager<Containers::vector>));
3427  static ::ROOT::TGenericClassInfo
3428  instance("Containers::KeyedObjectManager<Containers::vector>", "GaudiKernel/KeyedObjectManager.h", 46,
3429  typeid(::Containers::KeyedObjectManager<Containers::vector>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3430  &ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR_Dictionary, isa_proxy, 4,
3431  sizeof(::Containers::KeyedObjectManager<Containers::vector>) );
3432  instance.SetNew(&new_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR);
3433  instance.SetNewArray(&newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR);
3434  instance.SetDelete(&delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR);
3435  instance.SetDeleteArray(&deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR);
3436  instance.SetDestructor(&destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR);
3437  return &instance;
3438  }
3439  TGenericClassInfo *GenerateInitInstance(const ::Containers::KeyedObjectManager<Containers::vector>*)
3440  {
3441  return GenerateInitInstanceLocal((::Containers::KeyedObjectManager<Containers::vector>*)0);
3442  }
3443  // Static variable to force the class initialization
3444  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::vector>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3445 
3446  // Dictionary for non-ClassDef classes
3447  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR_Dictionary() {
3448  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::vector>*)0x0)->GetClass();
3449  ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR_TClassManip(theClass);
3450  return theClass;
3451  }
3452 
3453  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR_TClassManip(TClass* ){
3454  }
3455 
3456 } // end of namespace ROOT
3457 
3458 namespace ROOT {
3459  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR_Dictionary();
3460  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR_TClassManip(TClass*);
3461  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p = 0);
3462  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(Long_t size, void *p);
3463  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p);
3464  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p);
3465  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p);
3466 
3467  // Function generating the singleton type initializer
3468  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Containers::KeyedObjectManager<Containers::array>*)
3469  {
3470  ::Containers::KeyedObjectManager<Containers::array> *ptr = 0;
3471  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Containers::KeyedObjectManager<Containers::array>));
3472  static ::ROOT::TGenericClassInfo
3473  instance("Containers::KeyedObjectManager<Containers::array>", "GaudiKernel/KeyedObjectManager.h", 46,
3474  typeid(::Containers::KeyedObjectManager<Containers::array>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3475  &ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR_Dictionary, isa_proxy, 4,
3476  sizeof(::Containers::KeyedObjectManager<Containers::array>) );
3477  instance.SetNew(&new_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR);
3478  instance.SetNewArray(&newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR);
3479  instance.SetDelete(&delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR);
3480  instance.SetDeleteArray(&deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR);
3481  instance.SetDestructor(&destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR);
3482  return &instance;
3483  }
3484  TGenericClassInfo *GenerateInitInstance(const ::Containers::KeyedObjectManager<Containers::array>*)
3485  {
3486  return GenerateInitInstanceLocal((::Containers::KeyedObjectManager<Containers::array>*)0);
3487  }
3488  // Static variable to force the class initialization
3489  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::array>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3490 
3491  // Dictionary for non-ClassDef classes
3492  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR_Dictionary() {
3493  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::array>*)0x0)->GetClass();
3494  ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR_TClassManip(theClass);
3495  return theClass;
3496  }
3497 
3498  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR_TClassManip(TClass* ){
3499  }
3500 
3501 } // end of namespace ROOT
3502 
3503 namespace ROOT {
3504  static TClass *LinkManager_Dictionary();
3505  static void LinkManager_TClassManip(TClass*);
3506  static void *new_LinkManager(void *p = 0);
3507  static void *newArray_LinkManager(Long_t size, void *p);
3508  static void delete_LinkManager(void *p);
3509  static void deleteArray_LinkManager(void *p);
3510  static void destruct_LinkManager(void *p);
3511 
3512  // Function generating the singleton type initializer
3513  static TGenericClassInfo *GenerateInitInstanceLocal(const ::LinkManager*)
3514  {
3515  ::LinkManager *ptr = 0;
3516  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::LinkManager));
3517  static ::ROOT::TGenericClassInfo
3518  instance("LinkManager", "GaudiKernel/LinkManager.h", 21,
3519  typeid(::LinkManager), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3520  &LinkManager_Dictionary, isa_proxy, 4,
3521  sizeof(::LinkManager) );
3522  instance.SetNew(&new_LinkManager);
3523  instance.SetNewArray(&newArray_LinkManager);
3524  instance.SetDelete(&delete_LinkManager);
3525  instance.SetDeleteArray(&deleteArray_LinkManager);
3526  instance.SetDestructor(&destruct_LinkManager);
3527  return &instance;
3528  }
3529  TGenericClassInfo *GenerateInitInstance(const ::LinkManager*)
3530  {
3531  return GenerateInitInstanceLocal((::LinkManager*)0);
3532  }
3533  // Static variable to force the class initialization
3534  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::LinkManager*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3535 
3536  // Dictionary for non-ClassDef classes
3537  static TClass *LinkManager_Dictionary() {
3538  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::LinkManager*)0x0)->GetClass();
3539  LinkManager_TClassManip(theClass);
3540  return theClass;
3541  }
3542 
3543  static void LinkManager_TClassManip(TClass* ){
3544  }
3545 
3546 } // end of namespace ROOT
3547 
3548 namespace ROOT {
3549  static TClass *LinkManagercLcLLink_Dictionary();
3550  static void LinkManagercLcLLink_TClassManip(TClass*);
3551  static void *new_LinkManagercLcLLink(void *p = 0);
3552  static void *newArray_LinkManagercLcLLink(Long_t size, void *p);
3553  static void delete_LinkManagercLcLLink(void *p);
3554  static void deleteArray_LinkManagercLcLLink(void *p);
3555  static void destruct_LinkManagercLcLLink(void *p);
3556 
3557  // Function generating the singleton type initializer
3558  static TGenericClassInfo *GenerateInitInstanceLocal(const ::LinkManager::Link*)
3559  {
3560  ::LinkManager::Link *ptr = 0;
3561  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::LinkManager::Link));
3562  static ::ROOT::TGenericClassInfo
3563  instance("LinkManager::Link", "GaudiKernel/LinkManager.h", 32,
3564  typeid(::LinkManager::Link), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3565  &LinkManagercLcLLink_Dictionary, isa_proxy, 4,
3566  sizeof(::LinkManager::Link) );
3567  instance.SetNew(&new_LinkManagercLcLLink);
3568  instance.SetNewArray(&newArray_LinkManagercLcLLink);
3569  instance.SetDelete(&delete_LinkManagercLcLLink);
3570  instance.SetDeleteArray(&deleteArray_LinkManagercLcLLink);
3571  instance.SetDestructor(&destruct_LinkManagercLcLLink);
3572  return &instance;
3573  }
3574  TGenericClassInfo *GenerateInitInstance(const ::LinkManager::Link*)
3575  {
3576  return GenerateInitInstanceLocal((::LinkManager::Link*)0);
3577  }
3578  // Static variable to force the class initialization
3579  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::LinkManager::Link*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3580 
3581  // Dictionary for non-ClassDef classes
3582  static TClass *LinkManagercLcLLink_Dictionary() {
3583  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::LinkManager::Link*)0x0)->GetClass();
3584  LinkManagercLcLLink_TClassManip(theClass);
3585  return theClass;
3586  }
3587 
3588  static void LinkManagercLcLLink_TClassManip(TClass* ){
3589  }
3590 
3591 } // end of namespace ROOT
3592 
3593 namespace ROOT {
3594  static TClass *IJobOptionsSvc_Dictionary();
3595  static void IJobOptionsSvc_TClassManip(TClass*);
3596  static void delete_IJobOptionsSvc(void *p);
3597  static void deleteArray_IJobOptionsSvc(void *p);
3598  static void destruct_IJobOptionsSvc(void *p);
3599 
3600  // Function generating the singleton type initializer
3601  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IJobOptionsSvc*)
3602  {
3603  ::IJobOptionsSvc *ptr = 0;
3604  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IJobOptionsSvc));
3605  static ::ROOT::TGenericClassInfo
3606  instance("IJobOptionsSvc", "GaudiKernel/IJobOptionsSvc.h", 20,
3607  typeid(::IJobOptionsSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3608  &IJobOptionsSvc_Dictionary, isa_proxy, 4,
3609  sizeof(::IJobOptionsSvc) );
3610  instance.SetDelete(&delete_IJobOptionsSvc);
3611  instance.SetDeleteArray(&deleteArray_IJobOptionsSvc);
3612  instance.SetDestructor(&destruct_IJobOptionsSvc);
3613  return &instance;
3614  }
3615  TGenericClassInfo *GenerateInitInstance(const ::IJobOptionsSvc*)
3616  {
3617  return GenerateInitInstanceLocal((::IJobOptionsSvc*)0);
3618  }
3619  // Static variable to force the class initialization
3620  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IJobOptionsSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3621 
3622  // Dictionary for non-ClassDef classes
3623  static TClass *IJobOptionsSvc_Dictionary() {
3624  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IJobOptionsSvc*)0x0)->GetClass();
3625  IJobOptionsSvc_TClassManip(theClass);
3626  return theClass;
3627  }
3628 
3629  static void IJobOptionsSvc_TClassManip(TClass* ){
3630  }
3631 
3632 } // end of namespace ROOT
3633 
3634 namespace ROOT {
3635  static TClass *MetaData_Dictionary();
3636  static void MetaData_TClassManip(TClass*);
3637  static void *new_MetaData(void *p = 0);
3638  static void *newArray_MetaData(Long_t size, void *p);
3639  static void delete_MetaData(void *p);
3640  static void deleteArray_MetaData(void *p);
3641  static void destruct_MetaData(void *p);
3642 
3643  // Function generating the singleton type initializer
3644  static TGenericClassInfo *GenerateInitInstanceLocal(const ::MetaData*)
3645  {
3646  ::MetaData *ptr = 0;
3647  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::MetaData));
3648  static ::ROOT::TGenericClassInfo
3649  instance("MetaData", "GaudiKernel/MetaData.h", 21,
3650  typeid(::MetaData), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3651  &MetaData_Dictionary, isa_proxy, 4,
3652  sizeof(::MetaData) );
3653  instance.SetNew(&new_MetaData);
3654  instance.SetNewArray(&newArray_MetaData);
3655  instance.SetDelete(&delete_MetaData);
3656  instance.SetDeleteArray(&deleteArray_MetaData);
3657  instance.SetDestructor(&destruct_MetaData);
3658  return &instance;
3659  }
3660  TGenericClassInfo *GenerateInitInstance(const ::MetaData*)
3661  {
3662  return GenerateInitInstanceLocal((::MetaData*)0);
3663  }
3664  // Static variable to force the class initialization
3665  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::MetaData*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3666 
3667  // Dictionary for non-ClassDef classes
3668  static TClass *MetaData_Dictionary() {
3669  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::MetaData*)0x0)->GetClass();
3670  MetaData_TClassManip(theClass);
3671  return theClass;
3672  }
3673 
3674  static void MetaData_TClassManip(TClass* ){
3675  }
3676 
3677 } // end of namespace ROOT
3678 
3679 namespace ROOT {
3680  static TClass *SmartRefBase_Dictionary();
3681  static void SmartRefBase_TClassManip(TClass*);
3682  static void *new_SmartRefBase(void *p = 0);
3683  static void *newArray_SmartRefBase(Long_t size, void *p);
3684  static void delete_SmartRefBase(void *p);
3685  static void deleteArray_SmartRefBase(void *p);
3686  static void destruct_SmartRefBase(void *p);
3687 
3688  // Function generating the singleton type initializer
3689  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefBase*)
3690  {
3691  ::SmartRefBase *ptr = 0;
3692  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefBase));
3693  static ::ROOT::TGenericClassInfo
3694  instance("SmartRefBase", "GaudiKernel/SmartRefBase.h", 47,
3695  typeid(::SmartRefBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3696  &SmartRefBase_Dictionary, isa_proxy, 4,
3697  sizeof(::SmartRefBase) );
3698  instance.SetNew(&new_SmartRefBase);
3699  instance.SetNewArray(&newArray_SmartRefBase);
3700  instance.SetDelete(&delete_SmartRefBase);
3701  instance.SetDeleteArray(&deleteArray_SmartRefBase);
3702  instance.SetDestructor(&destruct_SmartRefBase);
3703  return &instance;
3704  }
3705  TGenericClassInfo *GenerateInitInstance(const ::SmartRefBase*)
3706  {
3707  return GenerateInitInstanceLocal((::SmartRefBase*)0);
3708  }
3709  // Static variable to force the class initialization
3710  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3711 
3712  // Dictionary for non-ClassDef classes
3713  static TClass *SmartRefBase_Dictionary() {
3714  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefBase*)0x0)->GetClass();
3715  SmartRefBase_TClassManip(theClass);
3716  return theClass;
3717  }
3718 
3719  static void SmartRefBase_TClassManip(TClass* ){
3720  }
3721 
3722 } // end of namespace ROOT
3723 
3724 namespace ROOT {
3725  static TClass *SmartReflEDataObjectgR_Dictionary();
3726  static void SmartReflEDataObjectgR_TClassManip(TClass*);
3727  static void *new_SmartReflEDataObjectgR(void *p = 0);
3728  static void *newArray_SmartReflEDataObjectgR(Long_t size, void *p);
3729  static void delete_SmartReflEDataObjectgR(void *p);
3730  static void deleteArray_SmartReflEDataObjectgR(void *p);
3731  static void destruct_SmartReflEDataObjectgR(void *p);
3732 
3733  // Function generating the singleton type initializer
3734  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<DataObject>*)
3735  {
3736  ::SmartRef<DataObject> *ptr = 0;
3737  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<DataObject>));
3738  static ::ROOT::TGenericClassInfo
3739  instance("SmartRef<DataObject>", "GaudiKernel/SmartRef.h", 66,
3740  typeid(::SmartRef<DataObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3741  &SmartReflEDataObjectgR_Dictionary, isa_proxy, 4,
3742  sizeof(::SmartRef<DataObject>) );
3743  instance.SetNew(&new_SmartReflEDataObjectgR);
3744  instance.SetNewArray(&newArray_SmartReflEDataObjectgR);
3745  instance.SetDelete(&delete_SmartReflEDataObjectgR);
3746  instance.SetDeleteArray(&deleteArray_SmartReflEDataObjectgR);
3747  instance.SetDestructor(&destruct_SmartReflEDataObjectgR);
3748  return &instance;
3749  }
3750  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<DataObject>*)
3751  {
3752  return GenerateInitInstanceLocal((::SmartRef<DataObject>*)0);
3753  }
3754  // Static variable to force the class initialization
3755  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<DataObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3756 
3757  // Dictionary for non-ClassDef classes
3758  static TClass *SmartReflEDataObjectgR_Dictionary() {
3759  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<DataObject>*)0x0)->GetClass();
3760  SmartReflEDataObjectgR_TClassManip(theClass);
3761  return theClass;
3762  }
3763 
3764  static void SmartReflEDataObjectgR_TClassManip(TClass* ){
3765  }
3766 
3767 } // end of namespace ROOT
3768 
3769 namespace ROOT {
3770  static TClass *SmartReflEContainedObjectgR_Dictionary();
3771  static void SmartReflEContainedObjectgR_TClassManip(TClass*);
3772  static void *new_SmartReflEContainedObjectgR(void *p = 0);
3773  static void *newArray_SmartReflEContainedObjectgR(Long_t size, void *p);
3774  static void delete_SmartReflEContainedObjectgR(void *p);
3775  static void deleteArray_SmartReflEContainedObjectgR(void *p);
3776  static void destruct_SmartReflEContainedObjectgR(void *p);
3777 
3778  // Function generating the singleton type initializer
3779  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<ContainedObject>*)
3780  {
3781  ::SmartRef<ContainedObject> *ptr = 0;
3782  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<ContainedObject>));
3783  static ::ROOT::TGenericClassInfo
3784  instance("SmartRef<ContainedObject>", "GaudiKernel/SmartRef.h", 66,
3785  typeid(::SmartRef<ContainedObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3786  &SmartReflEContainedObjectgR_Dictionary, isa_proxy, 4,
3787  sizeof(::SmartRef<ContainedObject>) );
3788  instance.SetNew(&new_SmartReflEContainedObjectgR);
3789  instance.SetNewArray(&newArray_SmartReflEContainedObjectgR);
3790  instance.SetDelete(&delete_SmartReflEContainedObjectgR);
3791  instance.SetDeleteArray(&deleteArray_SmartReflEContainedObjectgR);
3792  instance.SetDestructor(&destruct_SmartReflEContainedObjectgR);
3793  return &instance;
3794  }
3795  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<ContainedObject>*)
3796  {
3797  return GenerateInitInstanceLocal((::SmartRef<ContainedObject>*)0);
3798  }
3799  // Static variable to force the class initialization
3800  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<ContainedObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3801 
3802  // Dictionary for non-ClassDef classes
3803  static TClass *SmartReflEContainedObjectgR_Dictionary() {
3804  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<ContainedObject>*)0x0)->GetClass();
3805  SmartReflEContainedObjectgR_TClassManip(theClass);
3806  return theClass;
3807  }
3808 
3809  static void SmartReflEContainedObjectgR_TClassManip(TClass* ){
3810  }
3811 
3812 } // end of namespace ROOT
3813 
3814 namespace ROOT {
3815  static TClass *SmartReflEObjectContainerBasegR_Dictionary();
3816  static void SmartReflEObjectContainerBasegR_TClassManip(TClass*);
3817  static void *new_SmartReflEObjectContainerBasegR(void *p = 0);
3818  static void *newArray_SmartReflEObjectContainerBasegR(Long_t size, void *p);
3819  static void delete_SmartReflEObjectContainerBasegR(void *p);
3820  static void deleteArray_SmartReflEObjectContainerBasegR(void *p);
3821  static void destruct_SmartReflEObjectContainerBasegR(void *p);
3822 
3823  // Function generating the singleton type initializer
3824  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<ObjectContainerBase>*)
3825  {
3826  ::SmartRef<ObjectContainerBase> *ptr = 0;
3827  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<ObjectContainerBase>));
3828  static ::ROOT::TGenericClassInfo
3829  instance("SmartRef<ObjectContainerBase>", "GaudiKernel/SmartRef.h", 66,
3830  typeid(::SmartRef<ObjectContainerBase>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3831  &SmartReflEObjectContainerBasegR_Dictionary, isa_proxy, 4,
3832  sizeof(::SmartRef<ObjectContainerBase>) );
3833  instance.SetNew(&new_SmartReflEObjectContainerBasegR);
3834  instance.SetNewArray(&newArray_SmartReflEObjectContainerBasegR);
3835  instance.SetDelete(&delete_SmartReflEObjectContainerBasegR);
3836  instance.SetDeleteArray(&deleteArray_SmartReflEObjectContainerBasegR);
3837  instance.SetDestructor(&destruct_SmartReflEObjectContainerBasegR);
3838  return &instance;
3839  }
3840  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<ObjectContainerBase>*)
3841  {
3842  return GenerateInitInstanceLocal((::SmartRef<ObjectContainerBase>*)0);
3843  }
3844  // Static variable to force the class initialization
3845  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<ObjectContainerBase>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3846 
3847  // Dictionary for non-ClassDef classes
3848  static TClass *SmartReflEObjectContainerBasegR_Dictionary() {
3849  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<ObjectContainerBase>*)0x0)->GetClass();
3850  SmartReflEObjectContainerBasegR_TClassManip(theClass);
3851  return theClass;
3852  }
3853 
3854  static void SmartReflEObjectContainerBasegR_TClassManip(TClass* ){
3855  }
3856 
3857 } // end of namespace ROOT
3858 
3859 namespace ROOT {
3860  static TClass *SmartReflEKeyedObjectlEintgRsPgR_Dictionary();
3861  static void SmartReflEKeyedObjectlEintgRsPgR_TClassManip(TClass*);
3862  static void *new_SmartReflEKeyedObjectlEintgRsPgR(void *p = 0);
3863  static void *newArray_SmartReflEKeyedObjectlEintgRsPgR(Long_t size, void *p);
3864  static void delete_SmartReflEKeyedObjectlEintgRsPgR(void *p);
3865  static void deleteArray_SmartReflEKeyedObjectlEintgRsPgR(void *p);
3866  static void destruct_SmartReflEKeyedObjectlEintgRsPgR(void *p);
3867 
3868  // Function generating the singleton type initializer
3869  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<KeyedObject<int> >*)
3870  {
3871  ::SmartRef<KeyedObject<int> > *ptr = 0;
3872  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<KeyedObject<int> >));
3873  static ::ROOT::TGenericClassInfo
3874  instance("SmartRef<KeyedObject<int> >", "GaudiKernel/SmartRef.h", 66,
3875  typeid(::SmartRef<KeyedObject<int> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3876  &SmartReflEKeyedObjectlEintgRsPgR_Dictionary, isa_proxy, 4,
3877  sizeof(::SmartRef<KeyedObject<int> >) );
3878  instance.SetNew(&new_SmartReflEKeyedObjectlEintgRsPgR);
3879  instance.SetNewArray(&newArray_SmartReflEKeyedObjectlEintgRsPgR);
3880  instance.SetDelete(&delete_SmartReflEKeyedObjectlEintgRsPgR);
3881  instance.SetDeleteArray(&deleteArray_SmartReflEKeyedObjectlEintgRsPgR);
3882  instance.SetDestructor(&destruct_SmartReflEKeyedObjectlEintgRsPgR);
3883  return &instance;
3884  }
3885  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<KeyedObject<int> >*)
3886  {
3887  return GenerateInitInstanceLocal((::SmartRef<KeyedObject<int> >*)0);
3888  }
3889  // Static variable to force the class initialization
3890  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<int> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3891 
3892  // Dictionary for non-ClassDef classes
3893  static TClass *SmartReflEKeyedObjectlEintgRsPgR_Dictionary() {
3894  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<int> >*)0x0)->GetClass();
3895  SmartReflEKeyedObjectlEintgRsPgR_TClassManip(theClass);
3896  return theClass;
3897  }
3898 
3899  static void SmartReflEKeyedObjectlEintgRsPgR_TClassManip(TClass* ){
3900  }
3901 
3902 } // end of namespace ROOT
3903 
3904 namespace ROOT {
3905  static TClass *SmartReflEKeyedObjectlEunsignedsPintgRsPgR_Dictionary();
3906  static void SmartReflEKeyedObjectlEunsignedsPintgRsPgR_TClassManip(TClass*);
3907  static void *new_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p = 0);
3908  static void *newArray_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(Long_t size, void *p);
3909  static void delete_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p);
3910  static void deleteArray_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p);
3911  static void destruct_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p);
3912 
3913  // Function generating the singleton type initializer
3914  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<KeyedObject<unsigned int> >*)
3915  {
3916  ::SmartRef<KeyedObject<unsigned int> > *ptr = 0;
3917  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<KeyedObject<unsigned int> >));
3918  static ::ROOT::TGenericClassInfo
3919  instance("SmartRef<KeyedObject<unsigned int> >", "GaudiKernel/SmartRef.h", 66,
3920  typeid(::SmartRef<KeyedObject<unsigned int> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3921  &SmartReflEKeyedObjectlEunsignedsPintgRsPgR_Dictionary, isa_proxy, 4,
3922  sizeof(::SmartRef<KeyedObject<unsigned int> >) );
3923  instance.SetNew(&new_SmartReflEKeyedObjectlEunsignedsPintgRsPgR);
3924  instance.SetNewArray(&newArray_SmartReflEKeyedObjectlEunsignedsPintgRsPgR);
3925  instance.SetDelete(&delete_SmartReflEKeyedObjectlEunsignedsPintgRsPgR);
3926  instance.SetDeleteArray(&deleteArray_SmartReflEKeyedObjectlEunsignedsPintgRsPgR);
3927  instance.SetDestructor(&destruct_SmartReflEKeyedObjectlEunsignedsPintgRsPgR);
3928  return &instance;
3929  }
3930  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<KeyedObject<unsigned int> >*)
3931  {
3932  return GenerateInitInstanceLocal((::SmartRef<KeyedObject<unsigned int> >*)0);
3933  }
3934  // Static variable to force the class initialization
3935  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<unsigned int> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3936 
3937  // Dictionary for non-ClassDef classes
3938  static TClass *SmartReflEKeyedObjectlEunsignedsPintgRsPgR_Dictionary() {
3939  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<unsigned int> >*)0x0)->GetClass();
3940  SmartReflEKeyedObjectlEunsignedsPintgRsPgR_TClassManip(theClass);
3941  return theClass;
3942  }
3943 
3944  static void SmartReflEKeyedObjectlEunsignedsPintgRsPgR_TClassManip(TClass* ){
3945  }
3946 
3947 } // end of namespace ROOT
3948 
3949 namespace ROOT {
3950  static TClass *SmartReflEKeyedObjectlElonggRsPgR_Dictionary();
3951  static void SmartReflEKeyedObjectlElonggRsPgR_TClassManip(TClass*);
3952  static void *new_SmartReflEKeyedObjectlElonggRsPgR(void *p = 0);
3953  static void *newArray_SmartReflEKeyedObjectlElonggRsPgR(Long_t size, void *p);
3954  static void delete_SmartReflEKeyedObjectlElonggRsPgR(void *p);
3955  static void deleteArray_SmartReflEKeyedObjectlElonggRsPgR(void *p);
3956  static void destruct_SmartReflEKeyedObjectlElonggRsPgR(void *p);
3957 
3958  // Function generating the singleton type initializer
3959  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<KeyedObject<long> >*)
3960  {
3961  ::SmartRef<KeyedObject<long> > *ptr = 0;
3962  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<KeyedObject<long> >));
3963  static ::ROOT::TGenericClassInfo
3964  instance("SmartRef<KeyedObject<long> >", "GaudiKernel/SmartRef.h", 66,
3965  typeid(::SmartRef<KeyedObject<long> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3966  &SmartReflEKeyedObjectlElonggRsPgR_Dictionary, isa_proxy, 4,
3967  sizeof(::SmartRef<KeyedObject<long> >) );
3968  instance.SetNew(&new_SmartReflEKeyedObjectlElonggRsPgR);
3969  instance.SetNewArray(&newArray_SmartReflEKeyedObjectlElonggRsPgR);
3970  instance.SetDelete(&delete_SmartReflEKeyedObjectlElonggRsPgR);
3971  instance.SetDeleteArray(&deleteArray_SmartReflEKeyedObjectlElonggRsPgR);
3972  instance.SetDestructor(&destruct_SmartReflEKeyedObjectlElonggRsPgR);
3973  return &instance;
3974  }
3975  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<KeyedObject<long> >*)
3976  {
3977  return GenerateInitInstanceLocal((::SmartRef<KeyedObject<long> >*)0);
3978  }
3979  // Static variable to force the class initialization
3980  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<long> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3981 
3982  // Dictionary for non-ClassDef classes
3983  static TClass *SmartReflEKeyedObjectlElonggRsPgR_Dictionary() {
3984  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<long> >*)0x0)->GetClass();
3985  SmartReflEKeyedObjectlElonggRsPgR_TClassManip(theClass);
3986  return theClass;
3987  }
3988 
3989  static void SmartReflEKeyedObjectlElonggRsPgR_TClassManip(TClass* ){
3990  }
3991 
3992 } // end of namespace ROOT
3993 
3994 namespace ROOT {
3995  static TClass *SmartReflEKeyedObjectlEunsignedsPlonggRsPgR_Dictionary();
3996  static void SmartReflEKeyedObjectlEunsignedsPlonggRsPgR_TClassManip(TClass*);
3997  static void *new_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p = 0);
3998  static void *newArray_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(Long_t size, void *p);
3999  static void delete_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p);
4000  static void deleteArray_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p);
4001  static void destruct_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p);
4002 
4003  // Function generating the singleton type initializer
4004  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<KeyedObject<unsigned long> >*)
4005  {
4006  ::SmartRef<KeyedObject<unsigned long> > *ptr = 0;
4007  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<KeyedObject<unsigned long> >));
4008  static ::ROOT::TGenericClassInfo
4009  instance("SmartRef<KeyedObject<unsigned long> >", "GaudiKernel/SmartRef.h", 66,
4010  typeid(::SmartRef<KeyedObject<unsigned long> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4011  &SmartReflEKeyedObjectlEunsignedsPlonggRsPgR_Dictionary, isa_proxy, 4,
4012  sizeof(::SmartRef<KeyedObject<unsigned long> >) );
4013  instance.SetNew(&new_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR);
4014  instance.SetNewArray(&newArray_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR);
4015  instance.SetDelete(&delete_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR);
4016  instance.SetDeleteArray(&deleteArray_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR);
4017  instance.SetDestructor(&destruct_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR);
4018  return &instance;
4019  }
4020  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<KeyedObject<unsigned long> >*)
4021  {
4022  return GenerateInitInstanceLocal((::SmartRef<KeyedObject<unsigned long> >*)0);
4023  }
4024  // Static variable to force the class initialization
4025  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<unsigned long> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4026 
4027  // Dictionary for non-ClassDef classes
4028  static TClass *SmartReflEKeyedObjectlEunsignedsPlonggRsPgR_Dictionary() {
4029  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<unsigned long> >*)0x0)->GetClass();
4030  SmartReflEKeyedObjectlEunsignedsPlonggRsPgR_TClassManip(theClass);
4031  return theClass;
4032  }
4033 
4034  static void SmartReflEKeyedObjectlEunsignedsPlonggRsPgR_TClassManip(TClass* ){
4035  }
4036 
4037 } // end of namespace ROOT
4038 
4039 namespace ROOT {
4040  static TClass *INTuple_Dictionary();
4041  static void INTuple_TClassManip(TClass*);
4042  static void delete_INTuple(void *p);
4043  static void deleteArray_INTuple(void *p);
4044  static void destruct_INTuple(void *p);
4045 
4046  // Function generating the singleton type initializer
4047  static TGenericClassInfo *GenerateInitInstanceLocal(const ::INTuple*)
4048  {
4049  ::INTuple *ptr = 0;
4050  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::INTuple));
4051  static ::ROOT::TGenericClassInfo
4052  instance("INTuple", "GaudiKernel/INTuple.h", 82,
4053  typeid(::INTuple), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4054  &INTuple_Dictionary, isa_proxy, 4,
4055  sizeof(::INTuple) );
4056  instance.SetDelete(&delete_INTuple);
4057  instance.SetDeleteArray(&deleteArray_INTuple);
4058  instance.SetDestructor(&destruct_INTuple);
4059  return &instance;
4060  }
4061  TGenericClassInfo *GenerateInitInstance(const ::INTuple*)
4062  {
4063  return GenerateInitInstanceLocal((::INTuple*)0);
4064  }
4065  // Static variable to force the class initialization
4066  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::INTuple*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4067 
4068  // Dictionary for non-ClassDef classes
4069  static TClass *INTuple_Dictionary() {
4070  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::INTuple*)0x0)->GetClass();
4071  INTuple_TClassManip(theClass);
4072  return theClass;
4073  }
4074 
4075  static void INTuple_TClassManip(TClass* ){
4076  }
4077 
4078 } // end of namespace ROOT
4079 
4080 namespace ROOT {
4081  static TClass *SmartDataObjectPtr_Dictionary();
4082  static void SmartDataObjectPtr_TClassManip(TClass*);
4083  static void delete_SmartDataObjectPtr(void *p);
4084  static void deleteArray_SmartDataObjectPtr(void *p);
4085  static void destruct_SmartDataObjectPtr(void *p);
4086 
4087  // Function generating the singleton type initializer
4088  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataObjectPtr*)
4089  {
4090  ::SmartDataObjectPtr *ptr = 0;
4091  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataObjectPtr));
4092  static ::ROOT::TGenericClassInfo
4093  instance("SmartDataObjectPtr", "GaudiKernel/SmartDataObjectPtr.h", 32,
4094  typeid(::SmartDataObjectPtr), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4095  &SmartDataObjectPtr_Dictionary, isa_proxy, 4,
4096  sizeof(::SmartDataObjectPtr) );
4097  instance.SetDelete(&delete_SmartDataObjectPtr);
4098  instance.SetDeleteArray(&deleteArray_SmartDataObjectPtr);
4099  instance.SetDestructor(&destruct_SmartDataObjectPtr);
4100  return &instance;
4101  }
4102  TGenericClassInfo *GenerateInitInstance(const ::SmartDataObjectPtr*)
4103  {
4104  return GenerateInitInstanceLocal((::SmartDataObjectPtr*)0);
4105  }
4106  // Static variable to force the class initialization
4107  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataObjectPtr*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4108 
4109  // Dictionary for non-ClassDef classes
4110  static TClass *SmartDataObjectPtr_Dictionary() {
4111  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataObjectPtr*)0x0)->GetClass();
4112  SmartDataObjectPtr_TClassManip(theClass);
4113  return theClass;
4114  }
4115 
4116  static void SmartDataObjectPtr_TClassManip(TClass* ){
4117  }
4118 
4119 } // end of namespace ROOT
4120 
4121 namespace ROOT {
4122  static TClass *SmartDataObjectPtrcLcLObjectLoader_Dictionary();
4123  static void SmartDataObjectPtrcLcLObjectLoader_TClassManip(TClass*);
4124  static void *new_SmartDataObjectPtrcLcLObjectLoader(void *p = 0);
4125  static void *newArray_SmartDataObjectPtrcLcLObjectLoader(Long_t size, void *p);
4126  static void delete_SmartDataObjectPtrcLcLObjectLoader(void *p);
4127  static void deleteArray_SmartDataObjectPtrcLcLObjectLoader(void *p);
4128  static void destruct_SmartDataObjectPtrcLcLObjectLoader(void *p);
4129 
4130  // Function generating the singleton type initializer
4131  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataObjectPtr::ObjectLoader*)
4132  {
4133  ::SmartDataObjectPtr::ObjectLoader *ptr = 0;
4134  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataObjectPtr::ObjectLoader));
4135  static ::ROOT::TGenericClassInfo
4136  instance("SmartDataObjectPtr::ObjectLoader", "GaudiKernel/SmartDataObjectPtr.h", 37,
4137  typeid(::SmartDataObjectPtr::ObjectLoader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4138  &SmartDataObjectPtrcLcLObjectLoader_Dictionary, isa_proxy, 4,
4139  sizeof(::SmartDataObjectPtr::ObjectLoader) );
4140  instance.SetNew(&new_SmartDataObjectPtrcLcLObjectLoader);
4141  instance.SetNewArray(&newArray_SmartDataObjectPtrcLcLObjectLoader);
4142  instance.SetDelete(&delete_SmartDataObjectPtrcLcLObjectLoader);
4143  instance.SetDeleteArray(&deleteArray_SmartDataObjectPtrcLcLObjectLoader);
4144  instance.SetDestructor(&destruct_SmartDataObjectPtrcLcLObjectLoader);
4145  return &instance;
4146  }
4147  TGenericClassInfo *GenerateInitInstance(const ::SmartDataObjectPtr::ObjectLoader*)
4148  {
4149  return GenerateInitInstanceLocal((::SmartDataObjectPtr::ObjectLoader*)0);
4150  }
4151  // Static variable to force the class initialization
4152  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataObjectPtr::ObjectLoader*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4153 
4154  // Dictionary for non-ClassDef classes
4155  static TClass *SmartDataObjectPtrcLcLObjectLoader_Dictionary() {
4156  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataObjectPtr::ObjectLoader*)0x0)->GetClass();
4157  SmartDataObjectPtrcLcLObjectLoader_TClassManip(theClass);
4158  return theClass;
4159  }
4160 
4161  static void SmartDataObjectPtrcLcLObjectLoader_TClassManip(TClass* ){
4162  }
4163 
4164 } // end of namespace ROOT
4165 
4166 namespace ROOT {
4167  static TClass *SmartDataObjectPtrcLcLObjectFinder_Dictionary();
4168  static void SmartDataObjectPtrcLcLObjectFinder_TClassManip(TClass*);
4169  static void *new_SmartDataObjectPtrcLcLObjectFinder(void *p = 0);
4170  static void *newArray_SmartDataObjectPtrcLcLObjectFinder(Long_t size, void *p);
4171  static void delete_SmartDataObjectPtrcLcLObjectFinder(void *p);
4172  static void deleteArray_SmartDataObjectPtrcLcLObjectFinder(void *p);
4173  static void destruct_SmartDataObjectPtrcLcLObjectFinder(void *p);
4174 
4175  // Function generating the singleton type initializer
4176  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataObjectPtr::ObjectFinder*)
4177  {
4178  ::SmartDataObjectPtr::ObjectFinder *ptr = 0;
4179  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataObjectPtr::ObjectFinder));
4180  static ::ROOT::TGenericClassInfo
4181  instance("SmartDataObjectPtr::ObjectFinder", "GaudiKernel/SmartDataObjectPtr.h", 44,
4182  typeid(::SmartDataObjectPtr::ObjectFinder), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4183  &SmartDataObjectPtrcLcLObjectFinder_Dictionary, isa_proxy, 4,
4184  sizeof(::SmartDataObjectPtr::ObjectFinder) );
4185  instance.SetNew(&new_SmartDataObjectPtrcLcLObjectFinder);
4186  instance.SetNewArray(&newArray_SmartDataObjectPtrcLcLObjectFinder);
4187  instance.SetDelete(&delete_SmartDataObjectPtrcLcLObjectFinder);
4188  instance.SetDeleteArray(&deleteArray_SmartDataObjectPtrcLcLObjectFinder);
4189  instance.SetDestructor(&destruct_SmartDataObjectPtrcLcLObjectFinder);
4190  return &instance;
4191  }
4192  TGenericClassInfo *GenerateInitInstance(const ::SmartDataObjectPtr::ObjectFinder*)
4193  {
4194  return GenerateInitInstanceLocal((::SmartDataObjectPtr::ObjectFinder*)0);
4195  }
4196  // Static variable to force the class initialization
4197  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataObjectPtr::ObjectFinder*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4198 
4199  // Dictionary for non-ClassDef classes
4200  static TClass *SmartDataObjectPtrcLcLObjectFinder_Dictionary() {
4201  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataObjectPtr::ObjectFinder*)0x0)->GetClass();
4202  SmartDataObjectPtrcLcLObjectFinder_TClassManip(theClass);
4203  return theClass;
4204  }
4205 
4206  static void SmartDataObjectPtrcLcLObjectFinder_TClassManip(TClass* ){
4207  }
4208 
4209 } // end of namespace ROOT
4210 
4211 namespace ROOT {
4212  static TClass *SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR_Dictionary();
4213  static void SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR_TClassManip(TClass*);
4214  static void delete_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR(void *p);
4215  static void deleteArray_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR(void *p);
4216  static void destruct_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR(void *p);
4217 
4218  // Function generating the singleton type initializer
4219  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)
4220  {
4221  ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader> *ptr = 0;
4222  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>));
4223  static ::ROOT::TGenericClassInfo
4224  instance("SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>", "GaudiKernel/SmartDataStorePtr.h", 45,
4225  typeid(::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4226  &SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR_Dictionary, isa_proxy, 4,
4227  sizeof(::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>) );
4228  instance.SetDelete(&delete_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR);
4229  instance.SetDeleteArray(&deleteArray_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR);
4230  instance.SetDestructor(&destruct_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR);
4231  return &instance;
4232  }
4233  TGenericClassInfo *GenerateInitInstance(const ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)
4234  {
4235  return GenerateInitInstanceLocal((::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)0);
4236  }
4237  // Static variable to force the class initialization
4238  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4239 
4240  // Dictionary for non-ClassDef classes
4241  static TClass *SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR_Dictionary() {
4242  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)0x0)->GetClass();
4243  SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR_TClassManip(theClass);
4244  return theClass;
4245  }
4246 
4247  static void SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR_TClassManip(TClass* ){
4248  }
4249 
4250 } // end of namespace ROOT
4251 
4252 namespace ROOT {
4253  static TClass *SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR_Dictionary();
4254  static void SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR_TClassManip(TClass*);
4255  static void delete_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR(void *p);
4256  static void deleteArray_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR(void *p);
4257  static void destruct_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR(void *p);
4258 
4259  // Function generating the singleton type initializer
4260  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)
4261  {
4262  ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader> *ptr = 0;
4263  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>));
4264  static ::ROOT::TGenericClassInfo
4265  instance("SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>", "GaudiKernel/SmartDataStorePtr.h", 45,
4266  typeid(::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4267  &SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR_Dictionary, isa_proxy, 4,
4268  sizeof(::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>) );
4269  instance.SetDelete(&delete_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR);
4270  instance.SetDeleteArray(&deleteArray_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR);
4271  instance.SetDestructor(&destruct_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR);
4272  return &instance;
4273  }
4274  TGenericClassInfo *GenerateInitInstance(const ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)
4275  {
4276  return GenerateInitInstanceLocal((::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)0);
4277  }
4278  // Static variable to force the class initialization
4279  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4280 
4281  // Dictionary for non-ClassDef classes
4282  static TClass *SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR_Dictionary() {
4283  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)0x0)->GetClass();
4284  SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR_TClassManip(theClass);
4285  return theClass;
4286  }
4287 
4288  static void SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR_TClassManip(TClass* ){
4289  }
4290 
4291 } // end of namespace ROOT
4292 
4293 namespace ROOT {
4294  static TClass *SmartDataPtrlEDataObjectgR_Dictionary();
4295  static void SmartDataPtrlEDataObjectgR_TClassManip(TClass*);
4296  static void delete_SmartDataPtrlEDataObjectgR(void *p);
4297  static void deleteArray_SmartDataPtrlEDataObjectgR(void *p);
4298  static void destruct_SmartDataPtrlEDataObjectgR(void *p);
4299 
4300  // Function generating the singleton type initializer
4301  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataPtr<DataObject>*)
4302  {
4303  ::SmartDataPtr<DataObject> *ptr = 0;
4304  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataPtr<DataObject>));
4305  static ::ROOT::TGenericClassInfo
4306  instance("SmartDataPtr<DataObject>", "GaudiKernel/SmartDataPtr.h", 47,
4307  typeid(::SmartDataPtr<DataObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4308  &SmartDataPtrlEDataObjectgR_Dictionary, isa_proxy, 4,
4309  sizeof(::SmartDataPtr<DataObject>) );
4310  instance.SetDelete(&delete_SmartDataPtrlEDataObjectgR);
4311  instance.SetDeleteArray(&deleteArray_SmartDataPtrlEDataObjectgR);
4312  instance.SetDestructor(&destruct_SmartDataPtrlEDataObjectgR);
4313  return &instance;
4314  }
4315  TGenericClassInfo *GenerateInitInstance(const ::SmartDataPtr<DataObject>*)
4316  {
4317  return GenerateInitInstanceLocal((::SmartDataPtr<DataObject>*)0);
4318  }
4319  // Static variable to force the class initialization
4320  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataPtr<DataObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4321 
4322  // Dictionary for non-ClassDef classes
4323  static TClass *SmartDataPtrlEDataObjectgR_Dictionary() {
4324  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataPtr<DataObject>*)0x0)->GetClass();
4325  SmartDataPtrlEDataObjectgR_TClassManip(theClass);
4326  return theClass;
4327  }
4328 
4329  static void SmartDataPtrlEDataObjectgR_TClassManip(TClass* ){
4330  }
4331 
4332 } // end of namespace ROOT
4333 
4334 namespace ROOT {
4335  static TClass *SmartDataPtrlEObjectContainerBasegR_Dictionary();
4336  static void SmartDataPtrlEObjectContainerBasegR_TClassManip(TClass*);
4337  static void delete_SmartDataPtrlEObjectContainerBasegR(void *p);
4338  static void deleteArray_SmartDataPtrlEObjectContainerBasegR(void *p);
4339  static void destruct_SmartDataPtrlEObjectContainerBasegR(void *p);
4340 
4341  // Function generating the singleton type initializer
4342  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataPtr<ObjectContainerBase>*)
4343  {
4344  ::SmartDataPtr<ObjectContainerBase> *ptr = 0;
4345  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataPtr<ObjectContainerBase>));
4346  static ::ROOT::TGenericClassInfo
4347  instance("SmartDataPtr<ObjectContainerBase>", "GaudiKernel/SmartDataPtr.h", 47,
4348  typeid(::SmartDataPtr<ObjectContainerBase>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4349  &SmartDataPtrlEObjectContainerBasegR_Dictionary, isa_proxy, 4,
4350  sizeof(::SmartDataPtr<ObjectContainerBase>) );
4351  instance.SetDelete(&delete_SmartDataPtrlEObjectContainerBasegR);
4352  instance.SetDeleteArray(&deleteArray_SmartDataPtrlEObjectContainerBasegR);
4353  instance.SetDestructor(&destruct_SmartDataPtrlEObjectContainerBasegR);
4354  return &instance;
4355  }
4356  TGenericClassInfo *GenerateInitInstance(const ::SmartDataPtr<ObjectContainerBase>*)
4357  {
4358  return GenerateInitInstanceLocal((::SmartDataPtr<ObjectContainerBase>*)0);
4359  }
4360  // Static variable to force the class initialization
4361  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataPtr<ObjectContainerBase>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4362 
4363  // Dictionary for non-ClassDef classes
4364  static TClass *SmartDataPtrlEObjectContainerBasegR_Dictionary() {
4365  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataPtr<ObjectContainerBase>*)0x0)->GetClass();
4366  SmartDataPtrlEObjectContainerBasegR_TClassManip(theClass);
4367  return theClass;
4368  }
4369 
4370  static void SmartDataPtrlEObjectContainerBasegR_TClassManip(TClass* ){
4371  }
4372 
4373 } // end of namespace ROOT
4374 
4375 namespace ROOT {
4376  static TClass *NTuplecLcLItemlEchargR_Dictionary();
4377  static void NTuplecLcLItemlEchargR_TClassManip(TClass*);
4378  static void *new_NTuplecLcLItemlEchargR(void *p = 0);
4379  static void *newArray_NTuplecLcLItemlEchargR(Long_t size, void *p);
4380  static void delete_NTuplecLcLItemlEchargR(void *p);
4381  static void deleteArray_NTuplecLcLItemlEchargR(void *p);
4382  static void destruct_NTuplecLcLItemlEchargR(void *p);
4383 
4384  // Function generating the singleton type initializer
4385  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<char>*)
4386  {
4387  ::NTuple::Item<char> *ptr = 0;
4388  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<char>));
4389  static ::ROOT::TGenericClassInfo
4390  instance("NTuple::Item<char>", "GaudiKernel/NTuple.h", 262,
4391  typeid(::NTuple::Item<char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4392  &NTuplecLcLItemlEchargR_Dictionary, isa_proxy, 4,
4393  sizeof(::NTuple::Item<char>) );
4394  instance.SetNew(&new_NTuplecLcLItemlEchargR);
4395  instance.SetNewArray(&newArray_NTuplecLcLItemlEchargR);
4396  instance.SetDelete(&delete_NTuplecLcLItemlEchargR);
4397  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEchargR);
4398  instance.SetDestructor(&destruct_NTuplecLcLItemlEchargR);
4399  return &instance;
4400  }
4401  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<char>*)
4402  {
4403  return GenerateInitInstanceLocal((::NTuple::Item<char>*)0);
4404  }
4405  // Static variable to force the class initialization
4406  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4407 
4408  // Dictionary for non-ClassDef classes
4409  static TClass *NTuplecLcLItemlEchargR_Dictionary() {
4410  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<char>*)0x0)->GetClass();
4411  NTuplecLcLItemlEchargR_TClassManip(theClass);
4412  return theClass;
4413  }
4414 
4415  static void NTuplecLcLItemlEchargR_TClassManip(TClass* ){
4416  }
4417 
4418 } // end of namespace ROOT
4419 
4420 namespace ROOT {
4421  static TClass *NTuplecLcLItemlEunsignedsPchargR_Dictionary();
4422  static void NTuplecLcLItemlEunsignedsPchargR_TClassManip(TClass*);
4423  static void *new_NTuplecLcLItemlEunsignedsPchargR(void *p = 0);
4424  static void *newArray_NTuplecLcLItemlEunsignedsPchargR(Long_t size, void *p);
4425  static void delete_NTuplecLcLItemlEunsignedsPchargR(void *p);
4426  static void deleteArray_NTuplecLcLItemlEunsignedsPchargR(void *p);
4427  static void destruct_NTuplecLcLItemlEunsignedsPchargR(void *p);
4428 
4429  // Function generating the singleton type initializer
4430  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<unsigned char>*)
4431  {
4432  ::NTuple::Item<unsigned char> *ptr = 0;
4433  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<unsigned char>));
4434  static ::ROOT::TGenericClassInfo
4435  instance("NTuple::Item<unsigned char>", "GaudiKernel/NTuple.h", 262,
4436  typeid(::NTuple::Item<unsigned char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4437  &NTuplecLcLItemlEunsignedsPchargR_Dictionary, isa_proxy, 4,
4438  sizeof(::NTuple::Item<unsigned char>) );
4439  instance.SetNew(&new_NTuplecLcLItemlEunsignedsPchargR);
4440  instance.SetNewArray(&newArray_NTuplecLcLItemlEunsignedsPchargR);
4441  instance.SetDelete(&delete_NTuplecLcLItemlEunsignedsPchargR);
4442  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEunsignedsPchargR);
4443  instance.SetDestructor(&destruct_NTuplecLcLItemlEunsignedsPchargR);
4444  return &instance;
4445  }
4446  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<unsigned char>*)
4447  {
4448  return GenerateInitInstanceLocal((::NTuple::Item<unsigned char>*)0);
4449  }
4450  // Static variable to force the class initialization
4451  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<unsigned char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4452 
4453  // Dictionary for non-ClassDef classes
4454  static TClass *NTuplecLcLItemlEunsignedsPchargR_Dictionary() {
4455  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<unsigned char>*)0x0)->GetClass();
4456  NTuplecLcLItemlEunsignedsPchargR_TClassManip(theClass);
4457  return theClass;
4458  }
4459 
4460  static void NTuplecLcLItemlEunsignedsPchargR_TClassManip(TClass* ){
4461  }
4462 
4463 } // end of namespace ROOT
4464 
4465 namespace ROOT {
4466  static TClass *NTuplecLcLItemlEshortgR_Dictionary();
4467  static void NTuplecLcLItemlEshortgR_TClassManip(TClass*);
4468  static void *new_NTuplecLcLItemlEshortgR(void *p = 0);
4469  static void *newArray_NTuplecLcLItemlEshortgR(Long_t size, void *p);
4470  static void delete_NTuplecLcLItemlEshortgR(void *p);
4471  static void deleteArray_NTuplecLcLItemlEshortgR(void *p);
4472  static void destruct_NTuplecLcLItemlEshortgR(void *p);
4473 
4474  // Function generating the singleton type initializer
4475  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<short>*)
4476  {
4477  ::NTuple::Item<short> *ptr = 0;
4478  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<short>));
4479  static ::ROOT::TGenericClassInfo
4480  instance("NTuple::Item<short>", "GaudiKernel/NTuple.h", 262,
4481  typeid(::NTuple::Item<short>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4482  &NTuplecLcLItemlEshortgR_Dictionary, isa_proxy, 4,
4483  sizeof(::NTuple::Item<short>) );
4484  instance.SetNew(&new_NTuplecLcLItemlEshortgR);
4485  instance.SetNewArray(&newArray_NTuplecLcLItemlEshortgR);
4486  instance.SetDelete(&delete_NTuplecLcLItemlEshortgR);
4487  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEshortgR);
4488  instance.SetDestructor(&destruct_NTuplecLcLItemlEshortgR);
4489  return &instance;
4490  }
4491  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<short>*)
4492  {
4493  return GenerateInitInstanceLocal((::NTuple::Item<short>*)0);
4494  }
4495  // Static variable to force the class initialization
4496  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<short>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4497 
4498  // Dictionary for non-ClassDef classes
4499  static TClass *NTuplecLcLItemlEshortgR_Dictionary() {
4500  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<short>*)0x0)->GetClass();
4501  NTuplecLcLItemlEshortgR_TClassManip(theClass);
4502  return theClass;
4503  }
4504 
4505  static void NTuplecLcLItemlEshortgR_TClassManip(TClass* ){
4506  }
4507 
4508 } // end of namespace ROOT
4509 
4510 namespace ROOT {
4511  static TClass *NTuplecLcLItemlEunsignedsPshortgR_Dictionary();
4512  static void NTuplecLcLItemlEunsignedsPshortgR_TClassManip(TClass*);
4513  static void *new_NTuplecLcLItemlEunsignedsPshortgR(void *p = 0);
4514  static void *newArray_NTuplecLcLItemlEunsignedsPshortgR(Long_t size, void *p);
4515  static void delete_NTuplecLcLItemlEunsignedsPshortgR(void *p);
4516  static void deleteArray_NTuplecLcLItemlEunsignedsPshortgR(void *p);
4517  static void destruct_NTuplecLcLItemlEunsignedsPshortgR(void *p);
4518 
4519  // Function generating the singleton type initializer
4520  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<unsigned short>*)
4521  {
4522  ::NTuple::Item<unsigned short> *ptr = 0;
4523  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<unsigned short>));
4524  static ::ROOT::TGenericClassInfo
4525  instance("NTuple::Item<unsigned short>", "GaudiKernel/NTuple.h", 262,
4526  typeid(::NTuple::Item<unsigned short>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4527  &NTuplecLcLItemlEunsignedsPshortgR_Dictionary, isa_proxy, 4,
4528  sizeof(::NTuple::Item<unsigned short>) );
4529  instance.SetNew(&new_NTuplecLcLItemlEunsignedsPshortgR);
4530  instance.SetNewArray(&newArray_NTuplecLcLItemlEunsignedsPshortgR);
4531  instance.SetDelete(&delete_NTuplecLcLItemlEunsignedsPshortgR);
4532  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEunsignedsPshortgR);
4533  instance.SetDestructor(&destruct_NTuplecLcLItemlEunsignedsPshortgR);
4534  return &instance;
4535  }
4536  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<unsigned short>*)
4537  {
4538  return GenerateInitInstanceLocal((::NTuple::Item<unsigned short>*)0);
4539  }
4540  // Static variable to force the class initialization
4541  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<unsigned short>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4542 
4543  // Dictionary for non-ClassDef classes
4544  static TClass *NTuplecLcLItemlEunsignedsPshortgR_Dictionary() {
4545  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<unsigned short>*)0x0)->GetClass();
4546  NTuplecLcLItemlEunsignedsPshortgR_TClassManip(theClass);
4547  return theClass;
4548  }
4549 
4550  static void NTuplecLcLItemlEunsignedsPshortgR_TClassManip(TClass* ){
4551  }
4552 
4553 } // end of namespace ROOT
4554 
4555 namespace ROOT {
4556  static TClass *NTuplecLcLItemlElonggR_Dictionary();
4557  static void NTuplecLcLItemlElonggR_TClassManip(TClass*);
4558  static void *new_NTuplecLcLItemlElonggR(void *p = 0);
4559  static void *newArray_NTuplecLcLItemlElonggR(Long_t size, void *p);
4560  static void delete_NTuplecLcLItemlElonggR(void *p);
4561  static void deleteArray_NTuplecLcLItemlElonggR(void *p);
4562  static void destruct_NTuplecLcLItemlElonggR(void *p);
4563 
4564  // Function generating the singleton type initializer
4565  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<long>*)
4566  {
4567  ::NTuple::Item<long> *ptr = 0;
4568  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<long>));
4569  static ::ROOT::TGenericClassInfo
4570  instance("NTuple::Item<long>", "GaudiKernel/NTuple.h", 262,
4571  typeid(::NTuple::Item<long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4572  &NTuplecLcLItemlElonggR_Dictionary, isa_proxy, 4,
4573  sizeof(::NTuple::Item<long>) );
4574  instance.SetNew(&new_NTuplecLcLItemlElonggR);
4575  instance.SetNewArray(&newArray_NTuplecLcLItemlElonggR);
4576  instance.SetDelete(&delete_NTuplecLcLItemlElonggR);
4577  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlElonggR);
4578  instance.SetDestructor(&destruct_NTuplecLcLItemlElonggR);
4579  return &instance;
4580  }
4581  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<long>*)
4582  {
4583  return GenerateInitInstanceLocal((::NTuple::Item<long>*)0);
4584  }
4585  // Static variable to force the class initialization
4586  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4587 
4588  // Dictionary for non-ClassDef classes
4589  static TClass *NTuplecLcLItemlElonggR_Dictionary() {
4590  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<long>*)0x0)->GetClass();
4591  NTuplecLcLItemlElonggR_TClassManip(theClass);
4592  return theClass;
4593  }
4594 
4595  static void NTuplecLcLItemlElonggR_TClassManip(TClass* ){
4596  }
4597 
4598 } // end of namespace ROOT
4599 
4600 namespace ROOT {
4601  static TClass *NTuplecLcLItemlELong64_tgR_Dictionary();
4602  static void NTuplecLcLItemlELong64_tgR_TClassManip(TClass*);
4603  static void *new_NTuplecLcLItemlELong64_tgR(void *p = 0);
4604  static void *newArray_NTuplecLcLItemlELong64_tgR(Long_t size, void *p);
4605  static void delete_NTuplecLcLItemlELong64_tgR(void *p);
4606  static void deleteArray_NTuplecLcLItemlELong64_tgR(void *p);
4607  static void destruct_NTuplecLcLItemlELong64_tgR(void *p);
4608 
4609  // Function generating the singleton type initializer
4610  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<Long64_t>*)
4611  {
4612  ::NTuple::Item<Long64_t> *ptr = 0;
4613  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<Long64_t>));
4614  static ::ROOT::TGenericClassInfo
4615  instance("NTuple::Item<Long64_t>", "GaudiKernel/NTuple.h", 262,
4616  typeid(::NTuple::Item<Long64_t>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4617  &NTuplecLcLItemlELong64_tgR_Dictionary, isa_proxy, 4,
4618  sizeof(::NTuple::Item<Long64_t>) );
4619  instance.SetNew(&new_NTuplecLcLItemlELong64_tgR);
4620  instance.SetNewArray(&newArray_NTuplecLcLItemlELong64_tgR);
4621  instance.SetDelete(&delete_NTuplecLcLItemlELong64_tgR);
4622  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlELong64_tgR);
4623  instance.SetDestructor(&destruct_NTuplecLcLItemlELong64_tgR);
4624  return &instance;
4625  }
4626  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<Long64_t>*)
4627  {
4628  return GenerateInitInstanceLocal((::NTuple::Item<Long64_t>*)0);
4629  }
4630  // Static variable to force the class initialization
4631  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<Long64_t>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4632 
4633  // Dictionary for non-ClassDef classes
4634  static TClass *NTuplecLcLItemlELong64_tgR_Dictionary() {
4635  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<Long64_t>*)0x0)->GetClass();
4636  NTuplecLcLItemlELong64_tgR_TClassManip(theClass);
4637  return theClass;
4638  }
4639 
4640  static void NTuplecLcLItemlELong64_tgR_TClassManip(TClass* ){
4641  }
4642 
4643 } // end of namespace ROOT
4644 
4645 namespace ROOT {
4646  static TClass *NTuplecLcLItemlEunsignedsPlonggR_Dictionary();
4647  static void NTuplecLcLItemlEunsignedsPlonggR_TClassManip(TClass*);
4648  static void *new_NTuplecLcLItemlEunsignedsPlonggR(void *p = 0);
4649  static void *newArray_NTuplecLcLItemlEunsignedsPlonggR(Long_t size, void *p);
4650  static void delete_NTuplecLcLItemlEunsignedsPlonggR(void *p);
4651  static void deleteArray_NTuplecLcLItemlEunsignedsPlonggR(void *p);
4652  static void destruct_NTuplecLcLItemlEunsignedsPlonggR(void *p);
4653 
4654  // Function generating the singleton type initializer
4655  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<unsigned long>*)
4656  {
4657  ::NTuple::Item<unsigned long> *ptr = 0;
4658  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<unsigned long>));
4659  static ::ROOT::TGenericClassInfo
4660  instance("NTuple::Item<unsigned long>", "GaudiKernel/NTuple.h", 262,
4661  typeid(::NTuple::Item<unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4662  &NTuplecLcLItemlEunsignedsPlonggR_Dictionary, isa_proxy, 4,
4663  sizeof(::NTuple::Item<unsigned long>) );
4664  instance.SetNew(&new_NTuplecLcLItemlEunsignedsPlonggR);
4665  instance.SetNewArray(&newArray_NTuplecLcLItemlEunsignedsPlonggR);
4666  instance.SetDelete(&delete_NTuplecLcLItemlEunsignedsPlonggR);
4667  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEunsignedsPlonggR);
4668  instance.SetDestructor(&destruct_NTuplecLcLItemlEunsignedsPlonggR);
4669  return &instance;
4670  }
4671  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<unsigned long>*)
4672  {
4673  return GenerateInitInstanceLocal((::NTuple::Item<unsigned long>*)0);
4674  }
4675  // Static variable to force the class initialization
4676  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4677 
4678  // Dictionary for non-ClassDef classes
4679  static TClass *NTuplecLcLItemlEunsignedsPlonggR_Dictionary() {
4680  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<unsigned long>*)0x0)->GetClass();
4681  NTuplecLcLItemlEunsignedsPlonggR_TClassManip(theClass);
4682  return theClass;
4683  }
4684 
4685  static void NTuplecLcLItemlEunsignedsPlonggR_TClassManip(TClass* ){
4686  }
4687 
4688 } // end of namespace ROOT
4689 
4690 namespace ROOT {
4691  static TClass *NTuplecLcLItemlEULong64_tgR_Dictionary();
4692  static void NTuplecLcLItemlEULong64_tgR_TClassManip(TClass*);
4693  static void *new_NTuplecLcLItemlEULong64_tgR(void *p = 0);
4694  static void *newArray_NTuplecLcLItemlEULong64_tgR(Long_t size, void *p);
4695  static void delete_NTuplecLcLItemlEULong64_tgR(void *p);
4696  static void deleteArray_NTuplecLcLItemlEULong64_tgR(void *p);
4697  static void destruct_NTuplecLcLItemlEULong64_tgR(void *p);
4698 
4699  // Function generating the singleton type initializer
4700  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<ULong64_t>*)
4701  {
4702  ::NTuple::Item<ULong64_t> *ptr = 0;
4703  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<ULong64_t>));
4704  static ::ROOT::TGenericClassInfo
4705  instance("NTuple::Item<ULong64_t>", "GaudiKernel/NTuple.h", 262,
4706  typeid(::NTuple::Item<ULong64_t>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4707  &NTuplecLcLItemlEULong64_tgR_Dictionary, isa_proxy, 4,
4708  sizeof(::NTuple::Item<ULong64_t>) );
4709  instance.SetNew(&new_NTuplecLcLItemlEULong64_tgR);
4710  instance.SetNewArray(&newArray_NTuplecLcLItemlEULong64_tgR);
4711  instance.SetDelete(&delete_NTuplecLcLItemlEULong64_tgR);
4712  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEULong64_tgR);
4713  instance.SetDestructor(&destruct_NTuplecLcLItemlEULong64_tgR);
4714  return &instance;
4715  }
4716  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<ULong64_t>*)
4717  {
4718  return GenerateInitInstanceLocal((::NTuple::Item<ULong64_t>*)0);
4719  }
4720  // Static variable to force the class initialization
4721  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<ULong64_t>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4722 
4723  // Dictionary for non-ClassDef classes
4724  static TClass *NTuplecLcLItemlEULong64_tgR_Dictionary() {
4725  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<ULong64_t>*)0x0)->GetClass();
4726  NTuplecLcLItemlEULong64_tgR_TClassManip(theClass);
4727  return theClass;
4728  }
4729 
4730  static void NTuplecLcLItemlEULong64_tgR_TClassManip(TClass* ){
4731  }
4732 
4733 } // end of namespace ROOT
4734 
4735 namespace ROOT {
4736  static TClass *NTuplecLcLItemlEintgR_Dictionary();
4737  static void NTuplecLcLItemlEintgR_TClassManip(TClass*);
4738  static void *new_NTuplecLcLItemlEintgR(void *p = 0);
4739  static void *newArray_NTuplecLcLItemlEintgR(Long_t size, void *p);
4740  static void delete_NTuplecLcLItemlEintgR(void *p);
4741  static void deleteArray_NTuplecLcLItemlEintgR(void *p);
4742  static void destruct_NTuplecLcLItemlEintgR(void *p);
4743 
4744  // Function generating the singleton type initializer
4745  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<int>*)
4746  {
4747  ::NTuple::Item<int> *ptr = 0;
4748  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<int>));
4749  static ::ROOT::TGenericClassInfo
4750  instance("NTuple::Item<int>", "GaudiKernel/NTuple.h", 262,
4751  typeid(::NTuple::Item<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4752  &NTuplecLcLItemlEintgR_Dictionary, isa_proxy, 4,
4753  sizeof(::NTuple::Item<int>) );
4754  instance.SetNew(&new_NTuplecLcLItemlEintgR);
4755  instance.SetNewArray(&newArray_NTuplecLcLItemlEintgR);
4756  instance.SetDelete(&delete_NTuplecLcLItemlEintgR);
4757  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEintgR);
4758  instance.SetDestructor(&destruct_NTuplecLcLItemlEintgR);
4759  return &instance;
4760  }
4761  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<int>*)
4762  {
4763  return GenerateInitInstanceLocal((::NTuple::Item<int>*)0);
4764  }
4765  // Static variable to force the class initialization
4766  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4767 
4768  // Dictionary for non-ClassDef classes
4769  static TClass *NTuplecLcLItemlEintgR_Dictionary() {
4770  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<int>*)0x0)->GetClass();
4771  NTuplecLcLItemlEintgR_TClassManip(theClass);
4772  return theClass;
4773  }
4774 
4775  static void NTuplecLcLItemlEintgR_TClassManip(TClass* ){
4776  }
4777 
4778 } // end of namespace ROOT
4779 
4780 namespace ROOT {
4781  static TClass *NTuplecLcLItemlEunsignedsPintgR_Dictionary();
4782  static void NTuplecLcLItemlEunsignedsPintgR_TClassManip(TClass*);
4783  static void *new_NTuplecLcLItemlEunsignedsPintgR(void *p = 0);
4784  static void *newArray_NTuplecLcLItemlEunsignedsPintgR(Long_t size, void *p);
4785  static void delete_NTuplecLcLItemlEunsignedsPintgR(void *p);
4786  static void deleteArray_NTuplecLcLItemlEunsignedsPintgR(void *p);
4787  static void destruct_NTuplecLcLItemlEunsignedsPintgR(void *p);
4788 
4789  // Function generating the singleton type initializer
4790  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<unsigned int>*)
4791  {
4792  ::NTuple::Item<unsigned int> *ptr = 0;
4793  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<unsigned int>));
4794  static ::ROOT::TGenericClassInfo
4795  instance("NTuple::Item<unsigned int>", "GaudiKernel/NTuple.h", 262,
4796  typeid(::NTuple::Item<unsigned int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4797  &NTuplecLcLItemlEunsignedsPintgR_Dictionary, isa_proxy, 4,
4798  sizeof(::NTuple::Item<unsigned int>) );
4799  instance.SetNew(&new_NTuplecLcLItemlEunsignedsPintgR);
4800  instance.SetNewArray(&newArray_NTuplecLcLItemlEunsignedsPintgR);
4801  instance.SetDelete(&delete_NTuplecLcLItemlEunsignedsPintgR);
4802  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEunsignedsPintgR);
4803  instance.SetDestructor(&destruct_NTuplecLcLItemlEunsignedsPintgR);
4804  return &instance;
4805  }
4806  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<unsigned int>*)
4807  {
4808  return GenerateInitInstanceLocal((::NTuple::Item<unsigned int>*)0);
4809  }
4810  // Static variable to force the class initialization
4811  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4812 
4813  // Dictionary for non-ClassDef classes
4814  static TClass *NTuplecLcLItemlEunsignedsPintgR_Dictionary() {
4815  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<unsigned int>*)0x0)->GetClass();
4816  NTuplecLcLItemlEunsignedsPintgR_TClassManip(theClass);
4817  return theClass;
4818  }
4819 
4820  static void NTuplecLcLItemlEunsignedsPintgR_TClassManip(TClass* ){
4821  }
4822 
4823 } // end of namespace ROOT
4824 
4825 namespace ROOT {
4826  static TClass *NTuplecLcLItemlEfloatgR_Dictionary();
4827  static void NTuplecLcLItemlEfloatgR_TClassManip(TClass*);
4828  static void *new_NTuplecLcLItemlEfloatgR(void *p = 0);
4829  static void *newArray_NTuplecLcLItemlEfloatgR(Long_t size, void *p);
4830  static void delete_NTuplecLcLItemlEfloatgR(void *p);
4831  static void deleteArray_NTuplecLcLItemlEfloatgR(void *p);
4832  static void destruct_NTuplecLcLItemlEfloatgR(void *p);
4833 
4834  // Function generating the singleton type initializer
4835  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<float>*)
4836  {
4837  ::NTuple::Item<float> *ptr = 0;
4838  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<float>));
4839  static ::ROOT::TGenericClassInfo
4840  instance("NTuple::Item<float>", "GaudiKernel/NTuple.h", 262,
4841  typeid(::NTuple::Item<float>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4842  &NTuplecLcLItemlEfloatgR_Dictionary, isa_proxy, 4,
4843  sizeof(::NTuple::Item<float>) );
4844  instance.SetNew(&new_NTuplecLcLItemlEfloatgR);
4845  instance.SetNewArray(&newArray_NTuplecLcLItemlEfloatgR);
4846  instance.SetDelete(&delete_NTuplecLcLItemlEfloatgR);
4847  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEfloatgR);
4848  instance.SetDestructor(&destruct_NTuplecLcLItemlEfloatgR);
4849  return &instance;
4850  }
4851  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<float>*)
4852  {
4853  return GenerateInitInstanceLocal((::NTuple::Item<float>*)0);
4854  }
4855  // Static variable to force the class initialization
4856  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<float>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4857 
4858  // Dictionary for non-ClassDef classes
4859  static TClass *NTuplecLcLItemlEfloatgR_Dictionary() {
4860  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<float>*)0x0)->GetClass();
4861  NTuplecLcLItemlEfloatgR_TClassManip(theClass);
4862  return theClass;
4863  }
4864 
4865  static void NTuplecLcLItemlEfloatgR_TClassManip(TClass* ){
4866  }
4867 
4868 } // end of namespace ROOT
4869 
4870 namespace ROOT {
4871  static TClass *NTuplecLcLItemlEdoublegR_Dictionary();
4872  static void NTuplecLcLItemlEdoublegR_TClassManip(TClass*);
4873  static void *new_NTuplecLcLItemlEdoublegR(void *p = 0);
4874  static void *newArray_NTuplecLcLItemlEdoublegR(Long_t size, void *p);
4875  static void delete_NTuplecLcLItemlEdoublegR(void *p);
4876  static void deleteArray_NTuplecLcLItemlEdoublegR(void *p);
4877  static void destruct_NTuplecLcLItemlEdoublegR(void *p);
4878 
4879  // Function generating the singleton type initializer
4880  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<double>*)
4881  {
4882  ::NTuple::Item<double> *ptr = 0;
4883  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<double>));
4884  static ::ROOT::TGenericClassInfo
4885  instance("NTuple::Item<double>", "GaudiKernel/NTuple.h", 262,
4886  typeid(::NTuple::Item<double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4887  &NTuplecLcLItemlEdoublegR_Dictionary, isa_proxy, 4,
4888  sizeof(::NTuple::Item<double>) );
4889  instance.SetNew(&new_NTuplecLcLItemlEdoublegR);
4890  instance.SetNewArray(&newArray_NTuplecLcLItemlEdoublegR);
4891  instance.SetDelete(&delete_NTuplecLcLItemlEdoublegR);
4892  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEdoublegR);
4893  instance.SetDestructor(&destruct_NTuplecLcLItemlEdoublegR);
4894  return &instance;
4895  }
4896  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<double>*)
4897  {
4898  return GenerateInitInstanceLocal((::NTuple::Item<double>*)0);
4899  }
4900  // Static variable to force the class initialization
4901  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<double>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4902 
4903  // Dictionary for non-ClassDef classes
4904  static TClass *NTuplecLcLItemlEdoublegR_Dictionary() {
4905  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<double>*)0x0)->GetClass();
4906  NTuplecLcLItemlEdoublegR_TClassManip(theClass);
4907  return theClass;
4908  }
4909 
4910  static void NTuplecLcLItemlEdoublegR_TClassManip(TClass* ){
4911  }
4912 
4913 } // end of namespace ROOT
4914 
4915 namespace ROOT {
4916  static TClass *NTuplecLcLArraylEboolgR_Dictionary();
4917  static void NTuplecLcLArraylEboolgR_TClassManip(TClass*);
4918  static void *new_NTuplecLcLArraylEboolgR(void *p = 0);
4919  static void *newArray_NTuplecLcLArraylEboolgR(Long_t size, void *p);
4920  static void delete_NTuplecLcLArraylEboolgR(void *p);
4921  static void deleteArray_NTuplecLcLArraylEboolgR(void *p);
4922  static void destruct_NTuplecLcLArraylEboolgR(void *p);
4923 
4924  // Function generating the singleton type initializer
4925  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<bool>*)
4926  {
4927  ::NTuple::Array<bool> *ptr = 0;
4928  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<bool>));
4929  static ::ROOT::TGenericClassInfo
4930  instance("NTuple::Array<bool>", "GaudiKernel/NTuple.h", 345,
4931  typeid(::NTuple::Array<bool>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4932  &NTuplecLcLArraylEboolgR_Dictionary, isa_proxy, 4,
4933  sizeof(::NTuple::Array<bool>) );
4934  instance.SetNew(&new_NTuplecLcLArraylEboolgR);
4935  instance.SetNewArray(&newArray_NTuplecLcLArraylEboolgR);
4936  instance.SetDelete(&delete_NTuplecLcLArraylEboolgR);
4937  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEboolgR);
4938  instance.SetDestructor(&destruct_NTuplecLcLArraylEboolgR);
4939  return &instance;
4940  }
4941  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<bool>*)
4942  {
4943  return GenerateInitInstanceLocal((::NTuple::Array<bool>*)0);
4944  }
4945  // Static variable to force the class initialization
4946  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<bool>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4947 
4948  // Dictionary for non-ClassDef classes
4949  static TClass *NTuplecLcLArraylEboolgR_Dictionary() {
4950  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<bool>*)0x0)->GetClass();
4951  NTuplecLcLArraylEboolgR_TClassManip(theClass);
4952  return theClass;
4953  }
4954 
4955  static void NTuplecLcLArraylEboolgR_TClassManip(TClass* ){
4956  }
4957 
4958 } // end of namespace ROOT
4959 
4960 namespace ROOT {
4961  static TClass *NTuplecLcLArraylEchargR_Dictionary();
4962  static void NTuplecLcLArraylEchargR_TClassManip(TClass*);
4963  static void *new_NTuplecLcLArraylEchargR(void *p = 0);
4964  static void *newArray_NTuplecLcLArraylEchargR(Long_t size, void *p);
4965  static void delete_NTuplecLcLArraylEchargR(void *p);
4966  static void deleteArray_NTuplecLcLArraylEchargR(void *p);
4967  static void destruct_NTuplecLcLArraylEchargR(void *p);
4968 
4969  // Function generating the singleton type initializer
4970  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<char>*)
4971  {
4972  ::NTuple::Array<char> *ptr = 0;
4973  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<char>));
4974  static ::ROOT::TGenericClassInfo
4975  instance("NTuple::Array<char>", "GaudiKernel/NTuple.h", 345,
4976  typeid(::NTuple::Array<char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4977  &NTuplecLcLArraylEchargR_Dictionary, isa_proxy, 4,
4978  sizeof(::NTuple::Array<char>) );
4979  instance.SetNew(&new_NTuplecLcLArraylEchargR);
4980  instance.SetNewArray(&newArray_NTuplecLcLArraylEchargR);
4981  instance.SetDelete(&delete_NTuplecLcLArraylEchargR);
4982  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEchargR);
4983  instance.SetDestructor(&destruct_NTuplecLcLArraylEchargR);
4984  return &instance;
4985  }
4986  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<char>*)
4987  {
4988  return GenerateInitInstanceLocal((::NTuple::Array<char>*)0);
4989  }
4990  // Static variable to force the class initialization
4991  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4992 
4993  // Dictionary for non-ClassDef classes
4994  static TClass *NTuplecLcLArraylEchargR_Dictionary() {
4995  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<char>*)0x0)->GetClass();
4996  NTuplecLcLArraylEchargR_TClassManip(theClass);
4997  return theClass;
4998  }
4999 
5000  static void NTuplecLcLArraylEchargR_TClassManip(TClass* ){
5001  }
5002 
5003 } // end of namespace ROOT
5004 
5005 namespace ROOT {
5006  static TClass *NTuplecLcLArraylEunsignedsPchargR_Dictionary();
5007  static void NTuplecLcLArraylEunsignedsPchargR_TClassManip(TClass*);
5008  static void *new_NTuplecLcLArraylEunsignedsPchargR(void *p = 0);
5009  static void *newArray_NTuplecLcLArraylEunsignedsPchargR(Long_t size, void *p);
5010  static void delete_NTuplecLcLArraylEunsignedsPchargR(void *p);
5011  static void deleteArray_NTuplecLcLArraylEunsignedsPchargR(void *p);
5012  static void destruct_NTuplecLcLArraylEunsignedsPchargR(void *p);
5013 
5014  // Function generating the singleton type initializer
5015  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<unsigned char>*)
5016  {
5017  ::NTuple::Array<unsigned char> *ptr = 0;
5018  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<unsigned char>));
5019  static ::ROOT::TGenericClassInfo
5020  instance("NTuple::Array<unsigned char>", "GaudiKernel/NTuple.h", 345,
5021  typeid(::NTuple::Array<unsigned char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5022  &NTuplecLcLArraylEunsignedsPchargR_Dictionary, isa_proxy, 4,
5023  sizeof(::NTuple::Array<unsigned char>) );
5024  instance.SetNew(&new_NTuplecLcLArraylEunsignedsPchargR);
5025  instance.SetNewArray(&newArray_NTuplecLcLArraylEunsignedsPchargR);
5026  instance.SetDelete(&delete_NTuplecLcLArraylEunsignedsPchargR);
5027  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEunsignedsPchargR);
5028  instance.SetDestructor(&destruct_NTuplecLcLArraylEunsignedsPchargR);
5029  return &instance;
5030  }
5031  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<unsigned char>*)
5032  {
5033  return GenerateInitInstanceLocal((::NTuple::Array<unsigned char>*)0);
5034  }
5035  // Static variable to force the class initialization
5036  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<unsigned char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5037 
5038  // Dictionary for non-ClassDef classes
5039  static TClass *NTuplecLcLArraylEunsignedsPchargR_Dictionary() {
5040  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<unsigned char>*)0x0)->GetClass();
5041  NTuplecLcLArraylEunsignedsPchargR_TClassManip(theClass);
5042  return theClass;
5043  }
5044 
5045  static void NTuplecLcLArraylEunsignedsPchargR_TClassManip(TClass* ){
5046  }
5047 
5048 } // end of namespace ROOT
5049 
5050 namespace ROOT {
5051  static TClass *NTuplecLcLArraylEshortgR_Dictionary();
5052  static void NTuplecLcLArraylEshortgR_TClassManip(TClass*);
5053  static void *new_NTuplecLcLArraylEshortgR(void *p = 0);
5054  static void *newArray_NTuplecLcLArraylEshortgR(Long_t size, void *p);
5055  static void delete_NTuplecLcLArraylEshortgR(void *p);
5056  static void deleteArray_NTuplecLcLArraylEshortgR(void *p);
5057  static void destruct_NTuplecLcLArraylEshortgR(void *p);
5058 
5059  // Function generating the singleton type initializer
5060  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<short>*)
5061  {
5062  ::NTuple::Array<short> *ptr = 0;
5063  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<short>));
5064  static ::ROOT::TGenericClassInfo
5065  instance("NTuple::Array<short>", "GaudiKernel/NTuple.h", 345,
5066  typeid(::NTuple::Array<short>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5067  &NTuplecLcLArraylEshortgR_Dictionary, isa_proxy, 4,
5068  sizeof(::NTuple::Array<short>) );
5069  instance.SetNew(&new_NTuplecLcLArraylEshortgR);
5070  instance.SetNewArray(&newArray_NTuplecLcLArraylEshortgR);
5071  instance.SetDelete(&delete_NTuplecLcLArraylEshortgR);
5072  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEshortgR);
5073  instance.SetDestructor(&destruct_NTuplecLcLArraylEshortgR);
5074  return &instance;
5075  }
5076  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<short>*)
5077  {
5078  return GenerateInitInstanceLocal((::NTuple::Array<short>*)0);
5079  }
5080  // Static variable to force the class initialization
5081  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<short>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5082 
5083  // Dictionary for non-ClassDef classes
5084  static TClass *NTuplecLcLArraylEshortgR_Dictionary() {
5085  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<short>*)0x0)->GetClass();
5086  NTuplecLcLArraylEshortgR_TClassManip(theClass);
5087  return theClass;
5088  }
5089 
5090  static void NTuplecLcLArraylEshortgR_TClassManip(TClass* ){
5091  }
5092 
5093 } // end of namespace ROOT
5094 
5095 namespace ROOT {
5096  static TClass *NTuplecLcLArraylEunsignedsPshortgR_Dictionary();
5097  static void NTuplecLcLArraylEunsignedsPshortgR_TClassManip(TClass*);
5098  static void *new_NTuplecLcLArraylEunsignedsPshortgR(void *p = 0);
5099  static void *newArray_NTuplecLcLArraylEunsignedsPshortgR(Long_t size, void *p);
5100  static void delete_NTuplecLcLArraylEunsignedsPshortgR(void *p);
5101  static void deleteArray_NTuplecLcLArraylEunsignedsPshortgR(void *p);
5102  static void destruct_NTuplecLcLArraylEunsignedsPshortgR(void *p);
5103 
5104  // Function generating the singleton type initializer
5105  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<unsigned short>*)
5106  {
5107  ::NTuple::Array<unsigned short> *ptr = 0;
5108  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<unsigned short>));
5109  static ::ROOT::TGenericClassInfo
5110  instance("NTuple::Array<unsigned short>", "GaudiKernel/NTuple.h", 345,
5111  typeid(::NTuple::Array<unsigned short>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5112  &NTuplecLcLArraylEunsignedsPshortgR_Dictionary, isa_proxy, 4,
5113  sizeof(::NTuple::Array<unsigned short>) );
5114  instance.SetNew(&new_NTuplecLcLArraylEunsignedsPshortgR);
5115  instance.SetNewArray(&newArray_NTuplecLcLArraylEunsignedsPshortgR);
5116  instance.SetDelete(&delete_NTuplecLcLArraylEunsignedsPshortgR);
5117  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEunsignedsPshortgR);
5118  instance.SetDestructor(&destruct_NTuplecLcLArraylEunsignedsPshortgR);
5119  return &instance;
5120  }
5121  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<unsigned short>*)
5122  {
5123  return GenerateInitInstanceLocal((::NTuple::Array<unsigned short>*)0);
5124  }
5125  // Static variable to force the class initialization
5126  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<unsigned short>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5127 
5128  // Dictionary for non-ClassDef classes
5129  static TClass *NTuplecLcLArraylEunsignedsPshortgR_Dictionary() {
5130  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<unsigned short>*)0x0)->GetClass();
5131  NTuplecLcLArraylEunsignedsPshortgR_TClassManip(theClass);
5132  return theClass;
5133  }
5134 
5135  static void NTuplecLcLArraylEunsignedsPshortgR_TClassManip(TClass* ){
5136  }
5137 
5138 } // end of namespace ROOT
5139 
5140 namespace ROOT {
5141  static TClass *NTuplecLcLArraylElonggR_Dictionary();
5142  static void NTuplecLcLArraylElonggR_TClassManip(TClass*);
5143  static void *new_NTuplecLcLArraylElonggR(void *p = 0);
5144  static void *newArray_NTuplecLcLArraylElonggR(Long_t size, void *p);
5145  static void delete_NTuplecLcLArraylElonggR(void *p);
5146  static void deleteArray_NTuplecLcLArraylElonggR(void *p);
5147  static void destruct_NTuplecLcLArraylElonggR(void *p);
5148 
5149  // Function generating the singleton type initializer
5150  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<long>*)
5151  {
5152  ::NTuple::Array<long> *ptr = 0;
5153  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<long>));
5154  static ::ROOT::TGenericClassInfo
5155  instance("NTuple::Array<long>", "GaudiKernel/NTuple.h", 345,
5156  typeid(::NTuple::Array<long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5157  &NTuplecLcLArraylElonggR_Dictionary, isa_proxy, 4,
5158  sizeof(::NTuple::Array<long>) );
5159  instance.SetNew(&new_NTuplecLcLArraylElonggR);
5160  instance.SetNewArray(&newArray_NTuplecLcLArraylElonggR);
5161  instance.SetDelete(&delete_NTuplecLcLArraylElonggR);
5162  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylElonggR);
5163  instance.SetDestructor(&destruct_NTuplecLcLArraylElonggR);
5164  return &instance;
5165  }
5166  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<long>*)
5167  {
5168  return GenerateInitInstanceLocal((::NTuple::Array<long>*)0);
5169  }
5170  // Static variable to force the class initialization
5171  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5172 
5173  // Dictionary for non-ClassDef classes
5174  static TClass *NTuplecLcLArraylElonggR_Dictionary() {
5175  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<long>*)0x0)->GetClass();
5176  NTuplecLcLArraylElonggR_TClassManip(theClass);
5177  return theClass;
5178  }
5179 
5180  static void NTuplecLcLArraylElonggR_TClassManip(TClass* ){
5181  }
5182 
5183 } // end of namespace ROOT
5184 
5185 namespace ROOT {
5186  static TClass *NTuplecLcLArraylEunsignedsPlonggR_Dictionary();
5187  static void NTuplecLcLArraylEunsignedsPlonggR_TClassManip(TClass*);
5188  static void *new_NTuplecLcLArraylEunsignedsPlonggR(void *p = 0);
5189  static void *newArray_NTuplecLcLArraylEunsignedsPlonggR(Long_t size, void *p);
5190  static void delete_NTuplecLcLArraylEunsignedsPlonggR(void *p);
5191  static void deleteArray_NTuplecLcLArraylEunsignedsPlonggR(void *p);
5192  static void destruct_NTuplecLcLArraylEunsignedsPlonggR(void *p);
5193 
5194  // Function generating the singleton type initializer
5195  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<unsigned long>*)
5196  {
5197  ::NTuple::Array<unsigned long> *ptr = 0;
5198  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<unsigned long>));
5199  static ::ROOT::TGenericClassInfo
5200  instance("NTuple::Array<unsigned long>", "GaudiKernel/NTuple.h", 345,
5201  typeid(::NTuple::Array<unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5202  &NTuplecLcLArraylEunsignedsPlonggR_Dictionary, isa_proxy, 4,
5203  sizeof(::NTuple::Array<unsigned long>) );
5204  instance.SetNew(&new_NTuplecLcLArraylEunsignedsPlonggR);
5205  instance.SetNewArray(&newArray_NTuplecLcLArraylEunsignedsPlonggR);
5206  instance.SetDelete(&delete_NTuplecLcLArraylEunsignedsPlonggR);
5207  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEunsignedsPlonggR);
5208  instance.SetDestructor(&destruct_NTuplecLcLArraylEunsignedsPlonggR);
5209  return &instance;
5210  }
5211  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<unsigned long>*)
5212  {
5213  return GenerateInitInstanceLocal((::NTuple::Array<unsigned long>*)0);
5214  }
5215  // Static variable to force the class initialization
5216  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5217 
5218  // Dictionary for non-ClassDef classes
5219  static TClass *NTuplecLcLArraylEunsignedsPlonggR_Dictionary() {
5220  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<unsigned long>*)0x0)->GetClass();
5221  NTuplecLcLArraylEunsignedsPlonggR_TClassManip(theClass);
5222  return theClass;
5223  }
5224 
5225  static void NTuplecLcLArraylEunsignedsPlonggR_TClassManip(TClass* ){
5226  }
5227 
5228 } // end of namespace ROOT
5229 
5230 namespace ROOT {
5231  static TClass *NTuplecLcLArraylEintgR_Dictionary();
5232  static void NTuplecLcLArraylEintgR_TClassManip(TClass*);
5233  static void *new_NTuplecLcLArraylEintgR(void *p = 0);
5234  static void *newArray_NTuplecLcLArraylEintgR(Long_t size, void *p);
5235  static void delete_NTuplecLcLArraylEintgR(void *p);
5236  static void deleteArray_NTuplecLcLArraylEintgR(void *p);
5237  static void destruct_NTuplecLcLArraylEintgR(void *p);
5238 
5239  // Function generating the singleton type initializer
5240  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<int>*)
5241  {
5242  ::NTuple::Array<int> *ptr = 0;
5243  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<int>));
5244  static ::ROOT::TGenericClassInfo
5245  instance("NTuple::Array<int>", "GaudiKernel/NTuple.h", 345,
5246  typeid(::NTuple::Array<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5247  &NTuplecLcLArraylEintgR_Dictionary, isa_proxy, 4,
5248  sizeof(::NTuple::Array<int>) );
5249  instance.SetNew(&new_NTuplecLcLArraylEintgR);
5250  instance.SetNewArray(&newArray_NTuplecLcLArraylEintgR);
5251  instance.SetDelete(&delete_NTuplecLcLArraylEintgR);
5252  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEintgR);
5253  instance.SetDestructor(&destruct_NTuplecLcLArraylEintgR);
5254  return &instance;
5255  }
5256  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<int>*)
5257  {
5258  return GenerateInitInstanceLocal((::NTuple::Array<int>*)0);
5259  }
5260  // Static variable to force the class initialization
5261  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5262 
5263  // Dictionary for non-ClassDef classes
5264  static TClass *NTuplecLcLArraylEintgR_Dictionary() {
5265  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<int>*)0x0)->GetClass();
5266  NTuplecLcLArraylEintgR_TClassManip(theClass);
5267  return theClass;
5268  }
5269 
5270  static void NTuplecLcLArraylEintgR_TClassManip(TClass* ){
5271  }
5272 
5273 } // end of namespace ROOT
5274 
5275 namespace ROOT {
5276  static TClass *NTuplecLcLArraylEunsignedsPintgR_Dictionary();
5277  static void NTuplecLcLArraylEunsignedsPintgR_TClassManip(TClass*);
5278  static void *new_NTuplecLcLArraylEunsignedsPintgR(void *p = 0);
5279  static void *newArray_NTuplecLcLArraylEunsignedsPintgR(Long_t size, void *p);
5280  static void delete_NTuplecLcLArraylEunsignedsPintgR(void *p);
5281  static void deleteArray_NTuplecLcLArraylEunsignedsPintgR(void *p);
5282  static void destruct_NTuplecLcLArraylEunsignedsPintgR(void *p);
5283 
5284  // Function generating the singleton type initializer
5285  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<unsigned int>*)
5286  {
5287  ::NTuple::Array<unsigned int> *ptr = 0;
5288  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<unsigned int>));
5289  static ::ROOT::TGenericClassInfo
5290  instance("NTuple::Array<unsigned int>", "GaudiKernel/NTuple.h", 345,
5291  typeid(::NTuple::Array<unsigned int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5292  &NTuplecLcLArraylEunsignedsPintgR_Dictionary, isa_proxy, 4,
5293  sizeof(::NTuple::Array<unsigned int>) );
5294  instance.SetNew(&new_NTuplecLcLArraylEunsignedsPintgR);
5295  instance.SetNewArray(&newArray_NTuplecLcLArraylEunsignedsPintgR);
5296  instance.SetDelete(&delete_NTuplecLcLArraylEunsignedsPintgR);
5297  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEunsignedsPintgR);
5298  instance.SetDestructor(&destruct_NTuplecLcLArraylEunsignedsPintgR);
5299  return &instance;
5300  }
5301  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<unsigned int>*)
5302  {
5303  return GenerateInitInstanceLocal((::NTuple::Array<unsigned int>*)0);
5304  }
5305  // Static variable to force the class initialization
5306  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5307 
5308  // Dictionary for non-ClassDef classes
5309  static TClass *NTuplecLcLArraylEunsignedsPintgR_Dictionary() {
5310  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<unsigned int>*)0x0)->GetClass();
5311  NTuplecLcLArraylEunsignedsPintgR_TClassManip(theClass);
5312  return theClass;
5313  }
5314 
5315  static void NTuplecLcLArraylEunsignedsPintgR_TClassManip(TClass* ){
5316  }
5317 
5318 } // end of namespace ROOT
5319 
5320 namespace ROOT {
5321  static TClass *NTuplecLcLArraylEfloatgR_Dictionary();
5322  static void NTuplecLcLArraylEfloatgR_TClassManip(TClass*);
5323  static void *new_NTuplecLcLArraylEfloatgR(void *p = 0);
5324  static void *newArray_NTuplecLcLArraylEfloatgR(Long_t size, void *p);
5325  static void delete_NTuplecLcLArraylEfloatgR(void *p);
5326  static void deleteArray_NTuplecLcLArraylEfloatgR(void *p);
5327  static void destruct_NTuplecLcLArraylEfloatgR(void *p);
5328 
5329  // Function generating the singleton type initializer
5330  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<float>*)
5331  {
5332  ::NTuple::Array<float> *ptr = 0;
5333  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<float>));
5334  static ::ROOT::TGenericClassInfo
5335  instance("NTuple::Array<float>", "GaudiKernel/NTuple.h", 345,
5336  typeid(::NTuple::Array<float>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5337  &NTuplecLcLArraylEfloatgR_Dictionary, isa_proxy, 4,
5338  sizeof(::NTuple::Array<float>) );
5339  instance.SetNew(&new_NTuplecLcLArraylEfloatgR);
5340  instance.SetNewArray(&newArray_NTuplecLcLArraylEfloatgR);
5341  instance.SetDelete(&delete_NTuplecLcLArraylEfloatgR);
5342  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEfloatgR);
5343  instance.SetDestructor(&destruct_NTuplecLcLArraylEfloatgR);
5344  return &instance;
5345  }
5346  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<float>*)
5347  {
5348  return GenerateInitInstanceLocal((::NTuple::Array<float>*)0);
5349  }
5350  // Static variable to force the class initialization
5351  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<float>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5352 
5353  // Dictionary for non-ClassDef classes
5354  static TClass *NTuplecLcLArraylEfloatgR_Dictionary() {
5355  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<float>*)0x0)->GetClass();
5356  NTuplecLcLArraylEfloatgR_TClassManip(theClass);
5357  return theClass;
5358  }
5359 
5360  static void NTuplecLcLArraylEfloatgR_TClassManip(TClass* ){
5361  }
5362 
5363 } // end of namespace ROOT
5364 
5365 namespace ROOT {
5366  static TClass *NTuplecLcLArraylEdoublegR_Dictionary();
5367  static void NTuplecLcLArraylEdoublegR_TClassManip(TClass*);
5368  static void *new_NTuplecLcLArraylEdoublegR(void *p = 0);
5369  static void *newArray_NTuplecLcLArraylEdoublegR(Long_t size, void *p);
5370  static void delete_NTuplecLcLArraylEdoublegR(void *p);
5371  static void deleteArray_NTuplecLcLArraylEdoublegR(void *p);
5372  static void destruct_NTuplecLcLArraylEdoublegR(void *p);
5373 
5374  // Function generating the singleton type initializer
5375  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<double>*)
5376  {
5377  ::NTuple::Array<double> *ptr = 0;
5378  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<double>));
5379  static ::ROOT::TGenericClassInfo
5380  instance("NTuple::Array<double>", "GaudiKernel/NTuple.h", 345,
5381  typeid(::NTuple::Array<double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5382  &NTuplecLcLArraylEdoublegR_Dictionary, isa_proxy, 4,
5383  sizeof(::NTuple::Array<double>) );
5384  instance.SetNew(&new_NTuplecLcLArraylEdoublegR);
5385  instance.SetNewArray(&newArray_NTuplecLcLArraylEdoublegR);
5386  instance.SetDelete(&delete_NTuplecLcLArraylEdoublegR);
5387  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEdoublegR);
5388  instance.SetDestructor(&destruct_NTuplecLcLArraylEdoublegR);
5389  return &instance;
5390  }
5391  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<double>*)
5392  {
5393  return GenerateInitInstanceLocal((::NTuple::Array<double>*)0);
5394  }
5395  // Static variable to force the class initialization
5396  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<double>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5397 
5398  // Dictionary for non-ClassDef classes
5399  static TClass *NTuplecLcLArraylEdoublegR_Dictionary() {
5400  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<double>*)0x0)->GetClass();
5401  NTuplecLcLArraylEdoublegR_TClassManip(theClass);
5402  return theClass;
5403  }
5404 
5405  static void NTuplecLcLArraylEdoublegR_TClassManip(TClass* ){
5406  }
5407 
5408 } // end of namespace ROOT
5409 
5410 namespace ROOT {
5411  static TClass *NTuplecLcLMatrixlEboolgR_Dictionary();
5412  static void NTuplecLcLMatrixlEboolgR_TClassManip(TClass*);
5413  static void *new_NTuplecLcLMatrixlEboolgR(void *p = 0);
5414  static void *newArray_NTuplecLcLMatrixlEboolgR(Long_t size, void *p);
5415  static void delete_NTuplecLcLMatrixlEboolgR(void *p);
5416  static void deleteArray_NTuplecLcLMatrixlEboolgR(void *p);
5417  static void destruct_NTuplecLcLMatrixlEboolgR(void *p);
5418 
5419  // Function generating the singleton type initializer
5420  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<bool>*)
5421  {
5422  ::NTuple::Matrix<bool> *ptr = 0;
5423  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<bool>));
5424  static ::ROOT::TGenericClassInfo
5425  instance("NTuple::Matrix<bool>", "GaudiKernel/NTuple.h", 379,
5426  typeid(::NTuple::Matrix<bool>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5427  &NTuplecLcLMatrixlEboolgR_Dictionary, isa_proxy, 4,
5428  sizeof(::NTuple::Matrix<bool>) );
5429  instance.SetNew(&new_NTuplecLcLMatrixlEboolgR);
5430  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEboolgR);
5431  instance.SetDelete(&delete_NTuplecLcLMatrixlEboolgR);
5432  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEboolgR);
5433  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEboolgR);
5434  return &instance;
5435  }
5436  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<bool>*)
5437  {
5438  return GenerateInitInstanceLocal((::NTuple::Matrix<bool>*)0);
5439  }
5440  // Static variable to force the class initialization
5441  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<bool>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5442 
5443  // Dictionary for non-ClassDef classes
5444  static TClass *NTuplecLcLMatrixlEboolgR_Dictionary() {
5445  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<bool>*)0x0)->GetClass();
5446  NTuplecLcLMatrixlEboolgR_TClassManip(theClass);
5447  return theClass;
5448  }
5449 
5450  static void NTuplecLcLMatrixlEboolgR_TClassManip(TClass* ){
5451  }
5452 
5453 } // end of namespace ROOT
5454 
5455 namespace ROOT {
5456  static TClass *NTuplecLcLMatrixlEchargR_Dictionary();
5457  static void NTuplecLcLMatrixlEchargR_TClassManip(TClass*);
5458  static void *new_NTuplecLcLMatrixlEchargR(void *p = 0);
5459  static void *newArray_NTuplecLcLMatrixlEchargR(Long_t size, void *p);
5460  static void delete_NTuplecLcLMatrixlEchargR(void *p);
5461  static void deleteArray_NTuplecLcLMatrixlEchargR(void *p);
5462  static void destruct_NTuplecLcLMatrixlEchargR(void *p);
5463 
5464  // Function generating the singleton type initializer
5465  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<char>*)
5466  {
5467  ::NTuple::Matrix<char> *ptr = 0;
5468  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<char>));
5469  static ::ROOT::TGenericClassInfo
5470  instance("NTuple::Matrix<char>", "GaudiKernel/NTuple.h", 379,
5471  typeid(::NTuple::Matrix<char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5472  &NTuplecLcLMatrixlEchargR_Dictionary, isa_proxy, 4,
5473  sizeof(::NTuple::Matrix<char>) );
5474  instance.SetNew(&new_NTuplecLcLMatrixlEchargR);
5475  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEchargR);
5476  instance.SetDelete(&delete_NTuplecLcLMatrixlEchargR);
5477  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEchargR);
5478  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEchargR);
5479  return &instance;
5480  }
5481  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<char>*)
5482  {
5483  return GenerateInitInstanceLocal((::NTuple::Matrix<char>*)0);
5484  }
5485  // Static variable to force the class initialization
5486  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5487 
5488  // Dictionary for non-ClassDef classes
5489  static TClass *NTuplecLcLMatrixlEchargR_Dictionary() {
5490  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<char>*)0x0)->GetClass();
5491  NTuplecLcLMatrixlEchargR_TClassManip(theClass);
5492  return theClass;
5493  }
5494 
5495  static void NTuplecLcLMatrixlEchargR_TClassManip(TClass* ){
5496  }
5497 
5498 } // end of namespace ROOT
5499 
5500 namespace ROOT {
5501  static TClass *NTuplecLcLMatrixlEunsignedsPchargR_Dictionary();
5502  static void NTuplecLcLMatrixlEunsignedsPchargR_TClassManip(TClass*);
5503  static void *new_NTuplecLcLMatrixlEunsignedsPchargR(void *p = 0);
5504  static void *newArray_NTuplecLcLMatrixlEunsignedsPchargR(Long_t size, void *p);
5505  static void delete_NTuplecLcLMatrixlEunsignedsPchargR(void *p);
5506  static void deleteArray_NTuplecLcLMatrixlEunsignedsPchargR(void *p);
5507  static void destruct_NTuplecLcLMatrixlEunsignedsPchargR(void *p);
5508 
5509  // Function generating the singleton type initializer
5510  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<unsigned char>*)
5511  {
5512  ::NTuple::Matrix<unsigned char> *ptr = 0;
5513  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<unsigned char>));
5514  static ::ROOT::TGenericClassInfo
5515  instance("NTuple::Matrix<unsigned char>", "GaudiKernel/NTuple.h", 379,
5516  typeid(::NTuple::Matrix<unsigned char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5517  &NTuplecLcLMatrixlEunsignedsPchargR_Dictionary, isa_proxy, 4,
5518  sizeof(::NTuple::Matrix<unsigned char>) );
5519  instance.SetNew(&new_NTuplecLcLMatrixlEunsignedsPchargR);
5520  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEunsignedsPchargR);
5521  instance.SetDelete(&delete_NTuplecLcLMatrixlEunsignedsPchargR);
5522  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEunsignedsPchargR);
5523  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEunsignedsPchargR);
5524  return &instance;
5525  }
5526  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<unsigned char>*)
5527  {
5528  return GenerateInitInstanceLocal((::NTuple::Matrix<unsigned char>*)0);
5529  }
5530  // Static variable to force the class initialization
5531  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5532 
5533  // Dictionary for non-ClassDef classes
5534  static TClass *NTuplecLcLMatrixlEunsignedsPchargR_Dictionary() {
5535  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned char>*)0x0)->GetClass();
5536  NTuplecLcLMatrixlEunsignedsPchargR_TClassManip(theClass);
5537  return theClass;
5538  }
5539 
5540  static void NTuplecLcLMatrixlEunsignedsPchargR_TClassManip(TClass* ){
5541  }
5542 
5543 } // end of namespace ROOT
5544 
5545 namespace ROOT {
5546  static TClass *NTuplecLcLMatrixlEshortgR_Dictionary();
5547  static void NTuplecLcLMatrixlEshortgR_TClassManip(TClass*);
5548  static void *new_NTuplecLcLMatrixlEshortgR(void *p = 0);
5549  static void *newArray_NTuplecLcLMatrixlEshortgR(Long_t size, void *p);
5550  static void delete_NTuplecLcLMatrixlEshortgR(void *p);
5551  static void deleteArray_NTuplecLcLMatrixlEshortgR(void *p);
5552  static void destruct_NTuplecLcLMatrixlEshortgR(void *p);
5553 
5554  // Function generating the singleton type initializer
5555  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<short>*)
5556  {
5557  ::NTuple::Matrix<short> *ptr = 0;
5558  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<short>));
5559  static ::ROOT::TGenericClassInfo
5560  instance("NTuple::Matrix<short>", "GaudiKernel/NTuple.h", 379,
5561  typeid(::NTuple::Matrix<short>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5562  &NTuplecLcLMatrixlEshortgR_Dictionary, isa_proxy, 4,
5563  sizeof(::NTuple::Matrix<short>) );
5564  instance.SetNew(&new_NTuplecLcLMatrixlEshortgR);
5565  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEshortgR);
5566  instance.SetDelete(&delete_NTuplecLcLMatrixlEshortgR);
5567  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEshortgR);
5568  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEshortgR);
5569  return &instance;
5570  }
5571  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<short>*)
5572  {
5573  return GenerateInitInstanceLocal((::NTuple::Matrix<short>*)0);
5574  }
5575  // Static variable to force the class initialization
5576  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<short>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5577 
5578  // Dictionary for non-ClassDef classes
5579  static TClass *NTuplecLcLMatrixlEshortgR_Dictionary() {
5580  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<short>*)0x0)->GetClass();
5581  NTuplecLcLMatrixlEshortgR_TClassManip(theClass);
5582  return theClass;
5583  }
5584 
5585  static void NTuplecLcLMatrixlEshortgR_TClassManip(TClass* ){
5586  }
5587 
5588 } // end of namespace ROOT
5589 
5590 namespace ROOT {
5591  static TClass *NTuplecLcLMatrixlEunsignedsPshortgR_Dictionary();
5592  static void NTuplecLcLMatrixlEunsignedsPshortgR_TClassManip(TClass*);
5593  static void *new_NTuplecLcLMatrixlEunsignedsPshortgR(void *p = 0);
5594  static void *newArray_NTuplecLcLMatrixlEunsignedsPshortgR(Long_t size, void *p);
5595  static void delete_NTuplecLcLMatrixlEunsignedsPshortgR(void *p);
5596  static void deleteArray_NTuplecLcLMatrixlEunsignedsPshortgR(void *p);
5597  static void destruct_NTuplecLcLMatrixlEunsignedsPshortgR(void *p);
5598 
5599  // Function generating the singleton type initializer
5600  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<unsigned short>*)
5601  {
5602  ::NTuple::Matrix<unsigned short> *ptr = 0;
5603  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<unsigned short>));
5604  static ::ROOT::TGenericClassInfo
5605  instance("NTuple::Matrix<unsigned short>", "GaudiKernel/NTuple.h", 379,
5606  typeid(::NTuple::Matrix<unsigned short>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5607  &NTuplecLcLMatrixlEunsignedsPshortgR_Dictionary, isa_proxy, 4,
5608  sizeof(::NTuple::Matrix<unsigned short>) );
5609  instance.SetNew(&new_NTuplecLcLMatrixlEunsignedsPshortgR);
5610  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEunsignedsPshortgR);
5611  instance.SetDelete(&delete_NTuplecLcLMatrixlEunsignedsPshortgR);
5612  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEunsignedsPshortgR);
5613  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEunsignedsPshortgR);
5614  return &instance;
5615  }
5616  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<unsigned short>*)
5617  {
5618  return GenerateInitInstanceLocal((::NTuple::Matrix<unsigned short>*)0);
5619  }
5620  // Static variable to force the class initialization
5621  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned short>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5622 
5623  // Dictionary for non-ClassDef classes
5624  static TClass *NTuplecLcLMatrixlEunsignedsPshortgR_Dictionary() {
5625  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned short>*)0x0)->GetClass();
5626  NTuplecLcLMatrixlEunsignedsPshortgR_TClassManip(theClass);
5627  return theClass;
5628  }
5629 
5630  static void NTuplecLcLMatrixlEunsignedsPshortgR_TClassManip(TClass* ){
5631  }
5632 
5633 } // end of namespace ROOT
5634 
5635 namespace ROOT {
5636  static TClass *NTuplecLcLMatrixlElonggR_Dictionary();
5637  static void NTuplecLcLMatrixlElonggR_TClassManip(TClass*);
5638  static void *new_NTuplecLcLMatrixlElonggR(void *p = 0);
5639  static void *newArray_NTuplecLcLMatrixlElonggR(Long_t size, void *p);
5640  static void delete_NTuplecLcLMatrixlElonggR(void *p);
5641  static void deleteArray_NTuplecLcLMatrixlElonggR(void *p);
5642  static void destruct_NTuplecLcLMatrixlElonggR(void *p);
5643 
5644  // Function generating the singleton type initializer
5645  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<long>*)
5646  {
5647  ::NTuple::Matrix<long> *ptr = 0;
5648  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<long>));
5649  static ::ROOT::TGenericClassInfo
5650  instance("NTuple::Matrix<long>", "GaudiKernel/NTuple.h", 379,
5651  typeid(::NTuple::Matrix<long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5652  &NTuplecLcLMatrixlElonggR_Dictionary, isa_proxy, 4,
5653  sizeof(::NTuple::Matrix<long>) );
5654  instance.SetNew(&new_NTuplecLcLMatrixlElonggR);
5655  instance.SetNewArray(&newArray_NTuplecLcLMatrixlElonggR);
5656  instance.SetDelete(&delete_NTuplecLcLMatrixlElonggR);
5657  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlElonggR);
5658  instance.SetDestructor(&destruct_NTuplecLcLMatrixlElonggR);
5659  return &instance;
5660  }
5661  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<long>*)
5662  {
5663  return GenerateInitInstanceLocal((::NTuple::Matrix<long>*)0);
5664  }
5665  // Static variable to force the class initialization
5666  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5667 
5668  // Dictionary for non-ClassDef classes
5669  static TClass *NTuplecLcLMatrixlElonggR_Dictionary() {
5670  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<long>*)0x0)->GetClass();
5671  NTuplecLcLMatrixlElonggR_TClassManip(theClass);
5672  return theClass;
5673  }
5674 
5675  static void NTuplecLcLMatrixlElonggR_TClassManip(TClass* ){
5676  }
5677 
5678 } // end of namespace ROOT
5679 
5680 namespace ROOT {
5681  static TClass *NTuplecLcLMatrixlEunsignedsPlonggR_Dictionary();
5682  static void NTuplecLcLMatrixlEunsignedsPlonggR_TClassManip(TClass*);
5683  static void *new_NTuplecLcLMatrixlEunsignedsPlonggR(void *p = 0);
5684  static void *newArray_NTuplecLcLMatrixlEunsignedsPlonggR(Long_t size, void *p);
5685  static void delete_NTuplecLcLMatrixlEunsignedsPlonggR(void *p);
5686  static void deleteArray_NTuplecLcLMatrixlEunsignedsPlonggR(void *p);
5687  static void destruct_NTuplecLcLMatrixlEunsignedsPlonggR(void *p);
5688 
5689  // Function generating the singleton type initializer
5690  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<unsigned long>*)
5691  {
5692  ::NTuple::Matrix<unsigned long> *ptr = 0;
5693  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<unsigned long>));
5694  static ::ROOT::TGenericClassInfo
5695  instance("NTuple::Matrix<unsigned long>", "GaudiKernel/NTuple.h", 379,
5696  typeid(::NTuple::Matrix<unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5697  &NTuplecLcLMatrixlEunsignedsPlonggR_Dictionary, isa_proxy, 4,
5698  sizeof(::NTuple::Matrix<unsigned long>) );
5699  instance.SetNew(&new_NTuplecLcLMatrixlEunsignedsPlonggR);
5700  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEunsignedsPlonggR);
5701  instance.SetDelete(&delete_NTuplecLcLMatrixlEunsignedsPlonggR);
5702  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEunsignedsPlonggR);
5703  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEunsignedsPlonggR);
5704  return &instance;
5705  }
5706  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<unsigned long>*)
5707  {
5708  return GenerateInitInstanceLocal((::NTuple::Matrix<unsigned long>*)0);
5709  }
5710  // Static variable to force the class initialization
5711  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5712 
5713  // Dictionary for non-ClassDef classes
5714  static TClass *NTuplecLcLMatrixlEunsignedsPlonggR_Dictionary() {
5715  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned long>*)0x0)->GetClass();
5716  NTuplecLcLMatrixlEunsignedsPlonggR_TClassManip(theClass);
5717  return theClass;
5718  }
5719 
5720  static void NTuplecLcLMatrixlEunsignedsPlonggR_TClassManip(TClass* ){
5721  }
5722 
5723 } // end of namespace ROOT
5724 
5725 namespace ROOT {
5726  static TClass *NTuplecLcLMatrixlEintgR_Dictionary();
5727  static void NTuplecLcLMatrixlEintgR_TClassManip(TClass*);
5728  static void *new_NTuplecLcLMatrixlEintgR(void *p = 0);
5729  static void *newArray_NTuplecLcLMatrixlEintgR(Long_t size, void *p);
5730  static void delete_NTuplecLcLMatrixlEintgR(void *p);
5731  static void deleteArray_NTuplecLcLMatrixlEintgR(void *p);
5732  static void destruct_NTuplecLcLMatrixlEintgR(void *p);
5733 
5734  // Function generating the singleton type initializer
5735  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<int>*)
5736  {
5737  ::NTuple::Matrix<int> *ptr = 0;
5738  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<int>));
5739  static ::ROOT::TGenericClassInfo
5740  instance("NTuple::Matrix<int>", "GaudiKernel/NTuple.h", 379,
5741  typeid(::NTuple::Matrix<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5742  &NTuplecLcLMatrixlEintgR_Dictionary, isa_proxy, 4,
5743  sizeof(::NTuple::Matrix<int>) );
5744  instance.SetNew(&new_NTuplecLcLMatrixlEintgR);
5745  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEintgR);
5746  instance.SetDelete(&delete_NTuplecLcLMatrixlEintgR);
5747  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEintgR);
5748  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEintgR);
5749  return &instance;
5750  }
5751  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<int>*)
5752  {
5753  return GenerateInitInstanceLocal((::NTuple::Matrix<int>*)0);
5754  }
5755  // Static variable to force the class initialization
5756  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5757 
5758  // Dictionary for non-ClassDef classes
5759  static TClass *NTuplecLcLMatrixlEintgR_Dictionary() {
5760  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<int>*)0x0)->GetClass();
5761  NTuplecLcLMatrixlEintgR_TClassManip(theClass);
5762  return theClass;
5763  }
5764 
5765  static void NTuplecLcLMatrixlEintgR_TClassManip(TClass* ){
5766  }
5767 
5768 } // end of namespace ROOT
5769 
5770 namespace ROOT {
5771  static TClass *NTuplecLcLMatrixlEunsignedsPintgR_Dictionary();
5772  static void NTuplecLcLMatrixlEunsignedsPintgR_TClassManip(TClass*);
5773  static void *new_NTuplecLcLMatrixlEunsignedsPintgR(void *p = 0);
5774  static void *newArray_NTuplecLcLMatrixlEunsignedsPintgR(Long_t size, void *p);
5775  static void delete_NTuplecLcLMatrixlEunsignedsPintgR(void *p);
5776  static void deleteArray_NTuplecLcLMatrixlEunsignedsPintgR(void *p);
5777  static void destruct_NTuplecLcLMatrixlEunsignedsPintgR(void *p);
5778 
5779  // Function generating the singleton type initializer
5780  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<unsigned int>*)
5781  {
5782  ::NTuple::Matrix<unsigned int> *ptr = 0;
5783  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<unsigned int>));
5784  static ::ROOT::TGenericClassInfo
5785  instance("NTuple::Matrix<unsigned int>", "GaudiKernel/NTuple.h", 379,
5786  typeid(::NTuple::Matrix<unsigned int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5787  &NTuplecLcLMatrixlEunsignedsPintgR_Dictionary, isa_proxy, 4,
5788  sizeof(::NTuple::Matrix<unsigned int>) );
5789  instance.SetNew(&new_NTuplecLcLMatrixlEunsignedsPintgR);
5790  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEunsignedsPintgR);
5791  instance.SetDelete(&delete_NTuplecLcLMatrixlEunsignedsPintgR);
5792  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEunsignedsPintgR);
5793  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEunsignedsPintgR);
5794  return &instance;
5795  }
5796  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<unsigned int>*)
5797  {
5798  return GenerateInitInstanceLocal((::NTuple::Matrix<unsigned int>*)0);
5799  }
5800  // Static variable to force the class initialization
5801  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5802 
5803  // Dictionary for non-ClassDef classes
5804  static TClass *NTuplecLcLMatrixlEunsignedsPintgR_Dictionary() {
5805  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned int>*)0x0)->GetClass();
5806  NTuplecLcLMatrixlEunsignedsPintgR_TClassManip(theClass);
5807  return theClass;
5808  }
5809 
5810  static void NTuplecLcLMatrixlEunsignedsPintgR_TClassManip(TClass* ){
5811  }
5812 
5813 } // end of namespace ROOT
5814 
5815 namespace ROOT {
5816  static TClass *NTuplecLcLMatrixlEfloatgR_Dictionary();
5817  static void NTuplecLcLMatrixlEfloatgR_TClassManip(TClass*);
5818  static void *new_NTuplecLcLMatrixlEfloatgR(void *p = 0);
5819  static void *newArray_NTuplecLcLMatrixlEfloatgR(Long_t size, void *p);
5820  static void delete_NTuplecLcLMatrixlEfloatgR(void *p);
5821  static void deleteArray_NTuplecLcLMatrixlEfloatgR(void *p);
5822  static void destruct_NTuplecLcLMatrixlEfloatgR(void *p);
5823 
5824  // Function generating the singleton type initializer
5825  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<float>*)
5826  {
5827  ::NTuple::Matrix<float> *ptr = 0;
5828  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<float>));
5829  static ::ROOT::TGenericClassInfo
5830  instance("NTuple::Matrix<float>", "GaudiKernel/NTuple.h", 379,
5831  typeid(::NTuple::Matrix<float>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5832  &NTuplecLcLMatrixlEfloatgR_Dictionary, isa_proxy, 4,
5833  sizeof(::NTuple::Matrix<float>) );
5834  instance.SetNew(&new_NTuplecLcLMatrixlEfloatgR);
5835  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEfloatgR);
5836  instance.SetDelete(&delete_NTuplecLcLMatrixlEfloatgR);
5837  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEfloatgR);
5838  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEfloatgR);
5839  return &instance;
5840  }
5841  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<float>*)
5842  {
5843  return GenerateInitInstanceLocal((::NTuple::Matrix<float>*)0);
5844  }
5845  // Static variable to force the class initialization
5846  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<float>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5847 
5848  // Dictionary for non-ClassDef classes
5849  static TClass *NTuplecLcLMatrixlEfloatgR_Dictionary() {
5850  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<float>*)0x0)->GetClass();
5851  NTuplecLcLMatrixlEfloatgR_TClassManip(theClass);
5852  return theClass;
5853  }
5854 
5855  static void NTuplecLcLMatrixlEfloatgR_TClassManip(TClass* ){
5856  }
5857 
5858 } // end of namespace ROOT
5859 
5860 namespace ROOT {
5861  static TClass *NTuplecLcLMatrixlEdoublegR_Dictionary();
5862  static void NTuplecLcLMatrixlEdoublegR_TClassManip(TClass*);
5863  static void *new_NTuplecLcLMatrixlEdoublegR(void *p = 0);
5864  static void *newArray_NTuplecLcLMatrixlEdoublegR(Long_t size, void *p);
5865  static void delete_NTuplecLcLMatrixlEdoublegR(void *p);
5866  static void deleteArray_NTuplecLcLMatrixlEdoublegR(void *p);
5867  static void destruct_NTuplecLcLMatrixlEdoublegR(void *p);
5868 
5869  // Function generating the singleton type initializer
5870  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<double>*)
5871  {
5872  ::NTuple::Matrix<double> *ptr = 0;
5873  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<double>));
5874  static ::ROOT::TGenericClassInfo
5875  instance("NTuple::Matrix<double>", "GaudiKernel/NTuple.h", 379,
5876  typeid(::NTuple::Matrix<double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5877  &NTuplecLcLMatrixlEdoublegR_Dictionary, isa_proxy, 4,
5878  sizeof(::NTuple::Matrix<double>) );
5879  instance.SetNew(&new_NTuplecLcLMatrixlEdoublegR);
5880  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEdoublegR);
5881  instance.SetDelete(&delete_NTuplecLcLMatrixlEdoublegR);
5882  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEdoublegR);
5883  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEdoublegR);
5884  return &instance;
5885  }
5886  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<double>*)
5887  {
5888  return GenerateInitInstanceLocal((::NTuple::Matrix<double>*)0);
5889  }
5890  // Static variable to force the class initialization
5891  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<double>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5892 
5893  // Dictionary for non-ClassDef classes
5894  static TClass *NTuplecLcLMatrixlEdoublegR_Dictionary() {
5895  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<double>*)0x0)->GetClass();
5896  NTuplecLcLMatrixlEdoublegR_TClassManip(theClass);
5897  return theClass;
5898  }
5899 
5900  static void NTuplecLcLMatrixlEdoublegR_TClassManip(TClass* ){
5901  }
5902 
5903 } // end of namespace ROOT
5904 
5905 namespace ROOT {
5906  static TClass *NTuplecLcLItemlEboolgR_Dictionary();
5907  static void NTuplecLcLItemlEboolgR_TClassManip(TClass*);
5908  static void *new_NTuplecLcLItemlEboolgR(void *p = 0);
5909  static void *newArray_NTuplecLcLItemlEboolgR(Long_t size, void *p);
5910  static void delete_NTuplecLcLItemlEboolgR(void *p);
5911  static void deleteArray_NTuplecLcLItemlEboolgR(void *p);
5912  static void destruct_NTuplecLcLItemlEboolgR(void *p);
5913 
5914  // Function generating the singleton type initializer
5915  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<bool>*)
5916  {
5917  ::NTuple::Item<bool> *ptr = 0;
5918  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<bool>));
5919  static ::ROOT::TGenericClassInfo
5920  instance("NTuple::Item<bool>", "GaudiKernel/NTuple.h", 318,
5921  typeid(::NTuple::Item<bool>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5922  &NTuplecLcLItemlEboolgR_Dictionary, isa_proxy, 4,
5923  sizeof(::NTuple::Item<bool>) );
5924  instance.SetNew(&new_NTuplecLcLItemlEboolgR);
5925  instance.SetNewArray(&newArray_NTuplecLcLItemlEboolgR);
5926  instance.SetDelete(&delete_NTuplecLcLItemlEboolgR);
5927  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEboolgR);
5928  instance.SetDestructor(&destruct_NTuplecLcLItemlEboolgR);
5929  return &instance;
5930  }
5931  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<bool>*)
5932  {
5933  return GenerateInitInstanceLocal((::NTuple::Item<bool>*)0);
5934  }
5935  // Static variable to force the class initialization
5936  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<bool>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5937 
5938  // Dictionary for non-ClassDef classes
5939  static TClass *NTuplecLcLItemlEboolgR_Dictionary() {
5940  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<bool>*)0x0)->GetClass();
5941  NTuplecLcLItemlEboolgR_TClassManip(theClass);
5942  return theClass;
5943  }
5944 
5945  static void NTuplecLcLItemlEboolgR_TClassManip(TClass* ){
5946  }
5947 
5948 } // end of namespace ROOT
5949 
5950 namespace ROOT {
5951  static TClass *NTuplecLcLDirectory_Dictionary();
5952  static void NTuplecLcLDirectory_TClassManip(TClass*);
5953  static void *new_NTuplecLcLDirectory(void *p = 0);
5954  static void *newArray_NTuplecLcLDirectory(Long_t size, void *p);
5955  static void delete_NTuplecLcLDirectory(void *p);
5956  static void deleteArray_NTuplecLcLDirectory(void *p);
5957  static void destruct_NTuplecLcLDirectory(void *p);
5958 
5959  // Function generating the singleton type initializer
5960  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Directory*)
5961  {
5962  ::NTuple::Directory *ptr = 0;
5963  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Directory));
5964  static ::ROOT::TGenericClassInfo
5965  instance("NTuple::Directory", "GaudiKernel/NTuple.h", 986,
5966  typeid(::NTuple::Directory), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5967  &NTuplecLcLDirectory_Dictionary, isa_proxy, 4,
5968  sizeof(::NTuple::Directory) );
5969  instance.SetNew(&new_NTuplecLcLDirectory);
5970  instance.SetNewArray(&newArray_NTuplecLcLDirectory);
5971  instance.SetDelete(&delete_NTuplecLcLDirectory);
5972  instance.SetDeleteArray(&deleteArray_NTuplecLcLDirectory);
5973  instance.SetDestructor(&destruct_NTuplecLcLDirectory);
5974  return &instance;
5975  }
5976  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Directory*)
5977  {
5978  return GenerateInitInstanceLocal((::NTuple::Directory*)0);
5979  }
5980  // Static variable to force the class initialization
5981  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Directory*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5982 
5983  // Dictionary for non-ClassDef classes
5984  static TClass *NTuplecLcLDirectory_Dictionary() {
5985  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Directory*)0x0)->GetClass();
5986  NTuplecLcLDirectory_TClassManip(theClass);
5987  return theClass;
5988  }
5989 
5990  static void NTuplecLcLDirectory_TClassManip(TClass* theClass){
5991  theClass->CreateAttributeMap();
5992  TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
5993  attrMap->AddProperty("id","00000029-0000-0000-0000-000000000000");
5994  }
5995 
5996 } // end of namespace ROOT
5997 
5998 namespace ROOT {
5999  static TClass *NTuplecLcLFile_Dictionary();
6000  static void NTuplecLcLFile_TClassManip(TClass*);
6001  static void *new_NTuplecLcLFile(void *p = 0);
6002  static void *newArray_NTuplecLcLFile(Long_t size, void *p);
6003  static void delete_NTuplecLcLFile(void *p);
6004  static void deleteArray_NTuplecLcLFile(void *p);
6005  static void destruct_NTuplecLcLFile(void *p);
6006 
6007  // Function generating the singleton type initializer
6008  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::File*)
6009  {
6010  ::NTuple::File *ptr = 0;
6011  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::File));
6012  static ::ROOT::TGenericClassInfo
6013  instance("NTuple::File", "GaudiKernel/NTuple.h", 1002,
6014  typeid(::NTuple::File), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6015  &NTuplecLcLFile_Dictionary, isa_proxy, 4,
6016  sizeof(::NTuple::File) );
6017  instance.SetNew(&new_NTuplecLcLFile);
6018  instance.SetNewArray(&newArray_NTuplecLcLFile);
6019  instance.SetDelete(&delete_NTuplecLcLFile);
6020  instance.SetDeleteArray(&deleteArray_NTuplecLcLFile);
6021  instance.SetDestructor(&destruct_NTuplecLcLFile);
6022  return &instance;
6023  }
6024  TGenericClassInfo *GenerateInitInstance(const ::NTuple::File*)
6025  {
6026  return GenerateInitInstanceLocal((::NTuple::File*)0);
6027  }
6028  // Static variable to force the class initialization
6029  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::File*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6030 
6031  // Dictionary for non-ClassDef classes
6032  static TClass *NTuplecLcLFile_Dictionary() {
6033  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::File*)0x0)->GetClass();
6034  NTuplecLcLFile_TClassManip(theClass);
6035  return theClass;
6036  }
6037 
6038  static void NTuplecLcLFile_TClassManip(TClass* theClass){
6039  theClass->CreateAttributeMap();
6040  TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
6041  attrMap->AddProperty("id","00000028-0000-0000-0000-000000000000");
6042  }
6043 
6044 } // end of namespace ROOT
6045 
6046 namespace ROOT {
6047  static TClass *NTuplecLcLArraylEIOpaqueAddressmUgR_Dictionary();
6048  static void NTuplecLcLArraylEIOpaqueAddressmUgR_TClassManip(TClass*);
6049  static void delete_NTuplecLcLArraylEIOpaqueAddressmUgR(void *p);
6050  static void deleteArray_NTuplecLcLArraylEIOpaqueAddressmUgR(void *p);
6051  static void destruct_NTuplecLcLArraylEIOpaqueAddressmUgR(void *p);
6052 
6053  // Function generating the singleton type initializer
6054  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<IOpaqueAddress*>*)
6055  {
6056  ::NTuple::Array<IOpaqueAddress*> *ptr = 0;
6057  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<IOpaqueAddress*>));
6058  static ::ROOT::TGenericClassInfo
6059  instance("NTuple::Array<IOpaqueAddress*>", "GaudiKernel/NTuple.h", 1049,
6060  typeid(::NTuple::Array<IOpaqueAddress*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6061  &NTuplecLcLArraylEIOpaqueAddressmUgR_Dictionary, isa_proxy, 4,
6062  sizeof(::NTuple::Array<IOpaqueAddress*>) );
6063  instance.SetDelete(&delete_NTuplecLcLArraylEIOpaqueAddressmUgR);
6064  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEIOpaqueAddressmUgR);
6065  instance.SetDestructor(&destruct_NTuplecLcLArraylEIOpaqueAddressmUgR);
6066  return &instance;
6067  }
6068  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<IOpaqueAddress*>*)
6069  {
6070  return GenerateInitInstanceLocal((::NTuple::Array<IOpaqueAddress*>*)0);
6071  }
6072  // Static variable to force the class initialization
6073  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<IOpaqueAddress*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6074 
6075  // Dictionary for non-ClassDef classes
6076  static TClass *NTuplecLcLArraylEIOpaqueAddressmUgR_Dictionary() {
6077  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<IOpaqueAddress*>*)0x0)->GetClass();
6078  NTuplecLcLArraylEIOpaqueAddressmUgR_TClassManip(theClass);
6079  return theClass;
6080  }
6081 
6082  static void NTuplecLcLArraylEIOpaqueAddressmUgR_TClassManip(TClass* ){
6083  }
6084 
6085 } // end of namespace ROOT
6086 
6087 namespace ROOT {
6088  static TClass *NTuplecLcLMatrixlEIOpaqueAddressmUgR_Dictionary();
6089  static void NTuplecLcLMatrixlEIOpaqueAddressmUgR_TClassManip(TClass*);
6090  static void delete_NTuplecLcLMatrixlEIOpaqueAddressmUgR(void *p);
6091  static void deleteArray_NTuplecLcLMatrixlEIOpaqueAddressmUgR(void *p);
6092  static void destruct_NTuplecLcLMatrixlEIOpaqueAddressmUgR(void *p);
6093 
6094  // Function generating the singleton type initializer
6095  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<IOpaqueAddress*>*)
6096  {
6097  ::NTuple::Matrix<IOpaqueAddress*> *ptr = 0;
6098  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<IOpaqueAddress*>));
6099  static ::ROOT::TGenericClassInfo
6100  instance("NTuple::Matrix<IOpaqueAddress*>", "GaudiKernel/NTuple.h", 1058,
6101  typeid(::NTuple::Matrix<IOpaqueAddress*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6102  &NTuplecLcLMatrixlEIOpaqueAddressmUgR_Dictionary, isa_proxy, 4,
6103  sizeof(::NTuple::Matrix<IOpaqueAddress*>) );
6104  instance.SetDelete(&delete_NTuplecLcLMatrixlEIOpaqueAddressmUgR);
6105  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEIOpaqueAddressmUgR);
6106  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEIOpaqueAddressmUgR);
6107  return &instance;
6108  }
6109  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<IOpaqueAddress*>*)
6110  {
6111  return GenerateInitInstanceLocal((::NTuple::Matrix<IOpaqueAddress*>*)0);
6112  }
6113  // Static variable to force the class initialization
6114  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<IOpaqueAddress*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6115 
6116  // Dictionary for non-ClassDef classes
6117  static TClass *NTuplecLcLMatrixlEIOpaqueAddressmUgR_Dictionary() {
6118  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<IOpaqueAddress*>*)0x0)->GetClass();
6119  NTuplecLcLMatrixlEIOpaqueAddressmUgR_TClassManip(theClass);
6120  return theClass;
6121  }
6122 
6123  static void NTuplecLcLMatrixlEIOpaqueAddressmUgR_TClassManip(TClass* ){
6124  }
6125 
6126 } // end of namespace ROOT
6127 
6128 namespace ROOT {
6129  static TClass *NTuplecLcLColumnWiseTuple_Dictionary();
6130  static void NTuplecLcLColumnWiseTuple_TClassManip(TClass*);
6131  static void delete_NTuplecLcLColumnWiseTuple(void *p);
6132  static void deleteArray_NTuplecLcLColumnWiseTuple(void *p);
6133  static void destruct_NTuplecLcLColumnWiseTuple(void *p);
6134 
6135  // Function generating the singleton type initializer
6136  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::ColumnWiseTuple*)
6137  {
6138  ::NTuple::ColumnWiseTuple *ptr = 0;
6139  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::ColumnWiseTuple));
6140  static ::ROOT::TGenericClassInfo
6141  instance("NTuple::ColumnWiseTuple", "GaudiKernel/NTupleImplementation.h", 99,
6142  typeid(::NTuple::ColumnWiseTuple), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6143  &NTuplecLcLColumnWiseTuple_Dictionary, isa_proxy, 4,
6144  sizeof(::NTuple::ColumnWiseTuple) );
6145  instance.SetDelete(&delete_NTuplecLcLColumnWiseTuple);
6146  instance.SetDeleteArray(&deleteArray_NTuplecLcLColumnWiseTuple);
6147  instance.SetDestructor(&destruct_NTuplecLcLColumnWiseTuple);
6148  return &instance;
6149  }
6150  TGenericClassInfo *GenerateInitInstance(const ::NTuple::ColumnWiseTuple*)
6151  {
6152  return GenerateInitInstanceLocal((::NTuple::ColumnWiseTuple*)0);
6153  }
6154  // Static variable to force the class initialization
6155  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::ColumnWiseTuple*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6156 
6157  // Dictionary for non-ClassDef classes
6158  static TClass *NTuplecLcLColumnWiseTuple_Dictionary() {
6159  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::ColumnWiseTuple*)0x0)->GetClass();
6160  NTuplecLcLColumnWiseTuple_TClassManip(theClass);
6161  return theClass;
6162  }
6163 
6164  static void NTuplecLcLColumnWiseTuple_TClassManip(TClass* theClass){
6165  theClass->CreateAttributeMap();
6166  TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
6167  attrMap->AddProperty("id","0000002B-0000-0000-0000-000000000000");
6168  }
6169 
6170 } // end of namespace ROOT
6171 
6172 namespace ROOT {
6173  static TClass *NTuplecLcLRowWiseTuple_Dictionary();
6174  static void NTuplecLcLRowWiseTuple_TClassManip(TClass*);
6175  static void delete_NTuplecLcLRowWiseTuple(void *p);
6176  static void deleteArray_NTuplecLcLRowWiseTuple(void *p);
6177  static void destruct_NTuplecLcLRowWiseTuple(void *p);
6178 
6179  // Function generating the singleton type initializer
6180  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::RowWiseTuple*)
6181  {
6182  ::NTuple::RowWiseTuple *ptr = 0;
6183  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::RowWiseTuple));
6184  static ::ROOT::TGenericClassInfo
6185  instance("NTuple::RowWiseTuple", "GaudiKernel/NTupleImplementation.h", 113,
6186  typeid(::NTuple::RowWiseTuple), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6187  &NTuplecLcLRowWiseTuple_Dictionary, isa_proxy, 4,
6188  sizeof(::NTuple::RowWiseTuple) );
6189  instance.SetDelete(&delete_NTuplecLcLRowWiseTuple);
6190  instance.SetDeleteArray(&deleteArray_NTuplecLcLRowWiseTuple);
6191  instance.SetDestructor(&destruct_NTuplecLcLRowWiseTuple);
6192  return &instance;
6193  }
6194  TGenericClassInfo *GenerateInitInstance(const ::NTuple::RowWiseTuple*)
6195  {
6196  return GenerateInitInstanceLocal((::NTuple::RowWiseTuple*)0);
6197  }
6198  // Static variable to force the class initialization
6199  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::RowWiseTuple*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6200 
6201  // Dictionary for non-ClassDef classes
6202  static TClass *NTuplecLcLRowWiseTuple_Dictionary() {
6203  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::RowWiseTuple*)0x0)->GetClass();
6204  NTuplecLcLRowWiseTuple_TClassManip(theClass);
6205  return theClass;
6206  }
6207 
6208  static void NTuplecLcLRowWiseTuple_TClassManip(TClass* theClass){
6209  theClass->CreateAttributeMap();
6210  TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
6211  attrMap->AddProperty("id","0000002A-0000-0000-0000-000000000000");
6212  }
6213 
6214 } // end of namespace ROOT
6215 
6216 namespace ROOT {
6217  static TClass *IRegistry_Dictionary();
6218  static void IRegistry_TClassManip(TClass*);
6219  static void delete_IRegistry(void *p);
6220  static void deleteArray_IRegistry(void *p);
6221  static void destruct_IRegistry(void *p);
6222 
6223  // Function generating the singleton type initializer
6224  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IRegistry*)
6225  {
6226  ::IRegistry *ptr = 0;
6227  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IRegistry));
6228  static ::ROOT::TGenericClassInfo
6229  instance("IRegistry", "GaudiKernel/IRegistry.h", 22,
6230  typeid(::IRegistry), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6231  &IRegistry_Dictionary, isa_proxy, 4,
6232  sizeof(::IRegistry) );
6233  instance.SetDelete(&delete_IRegistry);
6234  instance.SetDeleteArray(&deleteArray_IRegistry);
6235  instance.SetDestructor(&destruct_IRegistry);
6236  return &instance;
6237  }
6238  TGenericClassInfo *GenerateInitInstance(const ::IRegistry*)
6239  {
6240  return GenerateInitInstanceLocal((::IRegistry*)0);
6241  }
6242  // Static variable to force the class initialization
6243  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IRegistry*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6244 
6245  // Dictionary for non-ClassDef classes
6246  static TClass *IRegistry_Dictionary() {
6247  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IRegistry*)0x0)->GetClass();
6248  IRegistry_TClassManip(theClass);
6249  return theClass;
6250  }
6251 
6252  static void IRegistry_TClassManip(TClass* ){
6253  }
6254 
6255 } // end of namespace ROOT
6256 
6257 namespace ROOT {
6258  static TClass *RndmcLcLGauss_Dictionary();
6259  static void RndmcLcLGauss_TClassManip(TClass*);
6260  static void delete_RndmcLcLGauss(void *p);
6261  static void deleteArray_RndmcLcLGauss(void *p);
6262  static void destruct_RndmcLcLGauss(void *p);
6263 
6264  // Function generating the singleton type initializer
6265  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Gauss*)
6266  {
6267  ::Rndm::Gauss *ptr = 0;
6268  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Gauss));
6269  static ::ROOT::TGenericClassInfo
6270  instance("Rndm::Gauss", "GaudiKernel/RndmGenerators.h", 23,
6271  typeid(::Rndm::Gauss), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6272  &RndmcLcLGauss_Dictionary, isa_proxy, 4,
6273  sizeof(::Rndm::Gauss) );
6274  instance.SetDelete(&delete_RndmcLcLGauss);
6275  instance.SetDeleteArray(&deleteArray_RndmcLcLGauss);
6276  instance.SetDestructor(&destruct_RndmcLcLGauss);
6277  return &instance;
6278  }
6279  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Gauss*)
6280  {
6281  return GenerateInitInstanceLocal((::Rndm::Gauss*)0);
6282  }
6283  // Static variable to force the class initialization
6284  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Gauss*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6285 
6286  // Dictionary for non-ClassDef classes
6287  static TClass *RndmcLcLGauss_Dictionary() {
6288  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Gauss*)0x0)->GetClass();
6289  RndmcLcLGauss_TClassManip(theClass);
6290  return theClass;
6291  }
6292 
6293  static void RndmcLcLGauss_TClassManip(TClass* ){
6294  }
6295 
6296 } // end of namespace ROOT
6297 
6298 namespace ROOT {
6299  static TClass *RndmcLcLExponential_Dictionary();
6300  static void RndmcLcLExponential_TClassManip(TClass*);
6301  static void delete_RndmcLcLExponential(void *p);
6302  static void deleteArray_RndmcLcLExponential(void *p);
6303  static void destruct_RndmcLcLExponential(void *p);
6304 
6305  // Function generating the singleton type initializer
6306  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Exponential*)
6307  {
6308  ::Rndm::Exponential *ptr = 0;
6309  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Exponential));
6310  static ::ROOT::TGenericClassInfo
6311  instance("Rndm::Exponential", "GaudiKernel/RndmGenerators.h", 50,
6312  typeid(::Rndm::Exponential), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6313  &RndmcLcLExponential_Dictionary, isa_proxy, 4,
6314  sizeof(::Rndm::Exponential) );
6315  instance.SetDelete(&delete_RndmcLcLExponential);
6316  instance.SetDeleteArray(&deleteArray_RndmcLcLExponential);
6317  instance.SetDestructor(&destruct_RndmcLcLExponential);
6318  return &instance;
6319  }
6320  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Exponential*)
6321  {
6322  return GenerateInitInstanceLocal((::Rndm::Exponential*)0);
6323  }
6324  // Static variable to force the class initialization
6325  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Exponential*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6326 
6327  // Dictionary for non-ClassDef classes
6328  static TClass *RndmcLcLExponential_Dictionary() {
6329  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Exponential*)0x0)->GetClass();
6330  RndmcLcLExponential_TClassManip(theClass);
6331  return theClass;
6332  }
6333 
6334  static void RndmcLcLExponential_TClassManip(TClass* ){
6335  }
6336 
6337 } // end of namespace ROOT
6338 
6339 namespace ROOT {
6340  static TClass *RndmcLcLChi2_Dictionary();
6341  static void RndmcLcLChi2_TClassManip(TClass*);
6342  static void delete_RndmcLcLChi2(void *p);
6343  static void deleteArray_RndmcLcLChi2(void *p);
6344  static void destruct_RndmcLcLChi2(void *p);
6345 
6346  // Function generating the singleton type initializer
6347  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Chi2*)
6348  {
6349  ::Rndm::Chi2 *ptr = 0;
6350  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Chi2));
6351  static ::ROOT::TGenericClassInfo
6352  instance("Rndm::Chi2", "GaudiKernel/RndmGenerators.h", 71,
6353  typeid(::Rndm::Chi2), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6354  &RndmcLcLChi2_Dictionary, isa_proxy, 4,
6355  sizeof(::Rndm::Chi2) );
6356  instance.SetDelete(&delete_RndmcLcLChi2);
6357  instance.SetDeleteArray(&deleteArray_RndmcLcLChi2);
6358  instance.SetDestructor(&destruct_RndmcLcLChi2);
6359  return &instance;
6360  }
6361  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Chi2*)
6362  {
6363  return GenerateInitInstanceLocal((::Rndm::Chi2*)0);
6364  }
6365  // Static variable to force the class initialization
6366  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Chi2*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6367 
6368  // Dictionary for non-ClassDef classes
6369  static TClass *RndmcLcLChi2_Dictionary() {
6370  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Chi2*)0x0)->GetClass();
6371  RndmcLcLChi2_TClassManip(theClass);
6372  return theClass;
6373  }
6374 
6375  static void RndmcLcLChi2_TClassManip(TClass* ){
6376  }
6377 
6378 } // end of namespace ROOT
6379 
6380 namespace ROOT {
6381  static TClass *RndmcLcLBreitWigner_Dictionary();
6382  static void RndmcLcLBreitWigner_TClassManip(TClass*);
6383  static void delete_RndmcLcLBreitWigner(void *p);
6384  static void deleteArray_RndmcLcLBreitWigner(void *p);
6385  static void destruct_RndmcLcLBreitWigner(void *p);
6386 
6387  // Function generating the singleton type initializer
6388  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::BreitWigner*)
6389  {
6390  ::Rndm::BreitWigner *ptr = 0;
6391  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::BreitWigner));
6392  static ::ROOT::TGenericClassInfo
6393  instance("Rndm::BreitWigner", "GaudiKernel/RndmGenerators.h", 94,
6394  typeid(::Rndm::BreitWigner), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6395  &RndmcLcLBreitWigner_Dictionary, isa_proxy, 4,
6396  sizeof(::Rndm::BreitWigner) );
6397  instance.SetDelete(&delete_RndmcLcLBreitWigner);
6398  instance.SetDeleteArray(&deleteArray_RndmcLcLBreitWigner);
6399  instance.SetDestructor(&destruct_RndmcLcLBreitWigner);
6400  return &instance;
6401  }
6402  TGenericClassInfo *GenerateInitInstance(const ::Rndm::BreitWigner*)
6403  {
6404  return GenerateInitInstanceLocal((::Rndm::BreitWigner*)0);
6405  }
6406  // Static variable to force the class initialization
6407  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::BreitWigner*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6408 
6409  // Dictionary for non-ClassDef classes
6410  static TClass *RndmcLcLBreitWigner_Dictionary() {
6411  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::BreitWigner*)0x0)->GetClass();
6412  RndmcLcLBreitWigner_TClassManip(theClass);
6413  return theClass;
6414  }
6415 
6416  static void RndmcLcLBreitWigner_TClassManip(TClass* ){
6417  }
6418 
6419 } // end of namespace ROOT
6420 
6421 namespace ROOT {
6422  static TClass *RndmcLcLLandau_Dictionary();
6423  static void RndmcLcLLandau_TClassManip(TClass*);
6424  static void delete_RndmcLcLLandau(void *p);
6425  static void deleteArray_RndmcLcLLandau(void *p);
6426  static void destruct_RndmcLcLLandau(void *p);
6427 
6428  // Function generating the singleton type initializer
6429  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Landau*)
6430  {
6431  ::Rndm::Landau *ptr = 0;
6432  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Landau));
6433  static ::ROOT::TGenericClassInfo
6434  instance("Rndm::Landau", "GaudiKernel/RndmGenerators.h", 119,
6435  typeid(::Rndm::Landau), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6436  &RndmcLcLLandau_Dictionary, isa_proxy, 4,
6437  sizeof(::Rndm::Landau) );
6438  instance.SetDelete(&delete_RndmcLcLLandau);
6439  instance.SetDeleteArray(&deleteArray_RndmcLcLLandau);
6440  instance.SetDestructor(&destruct_RndmcLcLLandau);
6441  return &instance;
6442  }
6443  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Landau*)
6444  {
6445  return GenerateInitInstanceLocal((::Rndm::Landau*)0);
6446  }
6447  // Static variable to force the class initialization
6448  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Landau*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6449 
6450  // Dictionary for non-ClassDef classes
6451  static TClass *RndmcLcLLandau_Dictionary() {
6452  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Landau*)0x0)->GetClass();
6453  RndmcLcLLandau_TClassManip(theClass);
6454  return theClass;
6455  }
6456 
6457  static void RndmcLcLLandau_TClassManip(TClass* ){
6458  }
6459 
6460 } // end of namespace ROOT
6461 
6462 namespace ROOT {
6463  static TClass *RndmcLcLBreitWignerCutOff_Dictionary();
6464  static void RndmcLcLBreitWignerCutOff_TClassManip(TClass*);
6465  static void delete_RndmcLcLBreitWignerCutOff(void *p);
6466  static void deleteArray_RndmcLcLBreitWignerCutOff(void *p);
6467  static void destruct_RndmcLcLBreitWignerCutOff(void *p);
6468 
6469  // Function generating the singleton type initializer
6470  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::BreitWignerCutOff*)
6471  {
6472  ::Rndm::BreitWignerCutOff *ptr = 0;
6473  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::BreitWignerCutOff));
6474  static ::ROOT::TGenericClassInfo
6475  instance("Rndm::BreitWignerCutOff", "GaudiKernel/RndmGenerators.h", 145,
6476  typeid(::Rndm::BreitWignerCutOff), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6477  &RndmcLcLBreitWignerCutOff_Dictionary, isa_proxy, 4,
6478  sizeof(::Rndm::BreitWignerCutOff) );
6479  instance.SetDelete(&delete_RndmcLcLBreitWignerCutOff);
6480  instance.SetDeleteArray(&deleteArray_RndmcLcLBreitWignerCutOff);
6481  instance.SetDestructor(&destruct_RndmcLcLBreitWignerCutOff);
6482  return &instance;
6483  }
6484  TGenericClassInfo *GenerateInitInstance(const ::Rndm::BreitWignerCutOff*)
6485  {
6486  return GenerateInitInstanceLocal((::Rndm::BreitWignerCutOff*)0);
6487  }
6488  // Static variable to force the class initialization
6489  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::BreitWignerCutOff*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6490 
6491  // Dictionary for non-ClassDef classes
6492  static TClass *RndmcLcLBreitWignerCutOff_Dictionary() {
6493  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::BreitWignerCutOff*)0x0)->GetClass();
6494  RndmcLcLBreitWignerCutOff_TClassManip(theClass);
6495  return theClass;
6496  }
6497 
6498  static void RndmcLcLBreitWignerCutOff_TClassManip(TClass* ){
6499  }
6500 
6501 } // end of namespace ROOT
6502 
6503 namespace ROOT {
6504  static TClass *RndmcLcLStudentT_Dictionary();
6505  static void RndmcLcLStudentT_TClassManip(TClass*);
6506  static void delete_RndmcLcLStudentT(void *p);
6507  static void deleteArray_RndmcLcLStudentT(void *p);
6508  static void destruct_RndmcLcLStudentT(void *p);
6509 
6510  // Function generating the singleton type initializer
6511  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::StudentT*)
6512  {
6513  ::Rndm::StudentT *ptr = 0;
6514  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::StudentT));
6515  static ::ROOT::TGenericClassInfo
6516  instance("Rndm::StudentT", "GaudiKernel/RndmGenerators.h", 175,
6517  typeid(::Rndm::StudentT), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6518  &RndmcLcLStudentT_Dictionary, isa_proxy, 4,
6519  sizeof(::Rndm::StudentT) );
6520  instance.SetDelete(&delete_RndmcLcLStudentT);
6521  instance.SetDeleteArray(&deleteArray_RndmcLcLStudentT);
6522  instance.SetDestructor(&destruct_RndmcLcLStudentT);
6523  return &instance;
6524  }
6525  TGenericClassInfo *GenerateInitInstance(const ::Rndm::StudentT*)
6526  {
6527  return GenerateInitInstanceLocal((::Rndm::StudentT*)0);
6528  }
6529  // Static variable to force the class initialization
6530  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::StudentT*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6531 
6532  // Dictionary for non-ClassDef classes
6533  static TClass *RndmcLcLStudentT_Dictionary() {
6534  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::StudentT*)0x0)->GetClass();
6535  RndmcLcLStudentT_TClassManip(theClass);
6536  return theClass;
6537  }
6538 
6539  static void RndmcLcLStudentT_TClassManip(TClass* ){
6540  }
6541 
6542 } // end of namespace ROOT
6543 
6544 namespace ROOT {
6545  static TClass *RndmcLcLGamma_Dictionary();
6546  static void RndmcLcLGamma_TClassManip(TClass*);
6547  static void delete_RndmcLcLGamma(void *p);
6548  static void deleteArray_RndmcLcLGamma(void *p);
6549  static void destruct_RndmcLcLGamma(void *p);
6550 
6551  // Function generating the singleton type initializer
6552  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Gamma*)
6553  {
6554  ::Rndm::Gamma *ptr = 0;
6555  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Gamma));
6556  static ::ROOT::TGenericClassInfo
6557  instance("Rndm::Gamma", "GaudiKernel/RndmGenerators.h", 198,
6558  typeid(::Rndm::Gamma), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6559  &RndmcLcLGamma_Dictionary, isa_proxy, 4,
6560  sizeof(::Rndm::Gamma) );
6561  instance.SetDelete(&delete_RndmcLcLGamma);
6562  instance.SetDeleteArray(&deleteArray_RndmcLcLGamma);
6563  instance.SetDestructor(&destruct_RndmcLcLGamma);
6564  return &instance;
6565  }
6566  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Gamma*)
6567  {
6568  return GenerateInitInstanceLocal((::Rndm::Gamma*)0);
6569  }
6570  // Static variable to force the class initialization
6571  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Gamma*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6572 
6573  // Dictionary for non-ClassDef classes
6574  static TClass *RndmcLcLGamma_Dictionary() {
6575  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Gamma*)0x0)->GetClass();
6576  RndmcLcLGamma_TClassManip(theClass);
6577  return theClass;
6578  }
6579 
6580  static void RndmcLcLGamma_TClassManip(TClass* ){
6581  }
6582 
6583 } // end of namespace ROOT
6584 
6585 namespace ROOT {
6586  static TClass *RndmcLcLPoisson_Dictionary();
6587  static void RndmcLcLPoisson_TClassManip(TClass*);
6588  static void delete_RndmcLcLPoisson(void *p);
6589  static void deleteArray_RndmcLcLPoisson(void *p);
6590  static void destruct_RndmcLcLPoisson(void *p);
6591 
6592  // Function generating the singleton type initializer
6593  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Poisson*)
6594  {
6595  ::Rndm::Poisson *ptr = 0;
6596  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Poisson));
6597  static ::ROOT::TGenericClassInfo
6598  instance("Rndm::Poisson", "GaudiKernel/RndmGenerators.h", 226,
6599  typeid(::Rndm::Poisson), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6600  &RndmcLcLPoisson_Dictionary, isa_proxy, 4,
6601  sizeof(::Rndm::Poisson) );
6602  instance.SetDelete(&delete_RndmcLcLPoisson);
6603  instance.SetDeleteArray(&deleteArray_RndmcLcLPoisson);
6604  instance.SetDestructor(&destruct_RndmcLcLPoisson);
6605  return &instance;
6606  }
6607  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Poisson*)
6608  {
6609  return GenerateInitInstanceLocal((::Rndm::Poisson*)0);
6610  }
6611  // Static variable to force the class initialization
6612  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Poisson*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6613 
6614  // Dictionary for non-ClassDef classes
6615  static TClass *RndmcLcLPoisson_Dictionary() {
6616  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Poisson*)0x0)->GetClass();
6617  RndmcLcLPoisson_TClassManip(theClass);
6618  return theClass;
6619  }
6620 
6621  static void RndmcLcLPoisson_TClassManip(TClass* ){
6622  }
6623 
6624 } // end of namespace ROOT
6625 
6626 namespace ROOT {
6627  static TClass *RndmcLcLBinomial_Dictionary();
6628  static void RndmcLcLBinomial_TClassManip(TClass*);
6629  static void delete_RndmcLcLBinomial(void *p);
6630  static void deleteArray_RndmcLcLBinomial(void *p);
6631  static void destruct_RndmcLcLBinomial(void *p);
6632 
6633  // Function generating the singleton type initializer
6634  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Binomial*)
6635  {
6636  ::Rndm::Binomial *ptr = 0;
6637  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Binomial));
6638  static ::ROOT::TGenericClassInfo
6639  instance("Rndm::Binomial", "GaudiKernel/RndmGenerators.h", 250,
6640  typeid(::Rndm::Binomial), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6641  &RndmcLcLBinomial_Dictionary, isa_proxy, 4,
6642  sizeof(::Rndm::Binomial) );
6643  instance.SetDelete(&delete_RndmcLcLBinomial);
6644  instance.SetDeleteArray(&deleteArray_RndmcLcLBinomial);
6645  instance.SetDestructor(&destruct_RndmcLcLBinomial);
6646  return &instance;
6647  }
6648  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Binomial*)
6649  {
6650  return GenerateInitInstanceLocal((::Rndm::Binomial*)0);
6651  }
6652  // Static variable to force the class initialization
6653  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Binomial*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6654 
6655  // Dictionary for non-ClassDef classes
6656  static TClass *RndmcLcLBinomial_Dictionary() {
6657  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Binomial*)0x0)->GetClass();
6658  RndmcLcLBinomial_TClassManip(theClass);
6659  return theClass;
6660  }
6661 
6662  static void RndmcLcLBinomial_TClassManip(TClass* ){
6663  }
6664 
6665 } // end of namespace ROOT
6666 
6667 namespace ROOT {
6668  static TClass *RndmcLcLFlat_Dictionary();
6669  static void RndmcLcLFlat_TClassManip(TClass*);
6670  static void delete_RndmcLcLFlat(void *p);
6671  static void deleteArray_RndmcLcLFlat(void *p);
6672  static void destruct_RndmcLcLFlat(void *p);
6673 
6674  // Function generating the singleton type initializer
6675  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Flat*)
6676  {
6677  ::Rndm::Flat *ptr = 0;
6678  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Flat));
6679  static ::ROOT::TGenericClassInfo
6680  instance("Rndm::Flat", "GaudiKernel/RndmGenerators.h", 276,
6681  typeid(::Rndm::Flat), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6682  &RndmcLcLFlat_Dictionary, isa_proxy, 4,
6683  sizeof(::Rndm::Flat) );
6684  instance.SetDelete(&delete_RndmcLcLFlat);
6685  instance.SetDeleteArray(&deleteArray_RndmcLcLFlat);
6686  instance.SetDestructor(&destruct_RndmcLcLFlat);
6687  return &instance;
6688  }
6689  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Flat*)
6690  {
6691  return GenerateInitInstanceLocal((::Rndm::Flat*)0);
6692  }
6693  // Static variable to force the class initialization
6694  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Flat*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6695 
6696  // Dictionary for non-ClassDef classes
6697  static TClass *RndmcLcLFlat_Dictionary() {
6698  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Flat*)0x0)->GetClass();
6699  RndmcLcLFlat_TClassManip(theClass);
6700  return theClass;
6701  }
6702 
6703  static void RndmcLcLFlat_TClassManip(TClass* ){
6704  }
6705 
6706 } // end of namespace ROOT
6707 
6708 namespace ROOT {
6709  static TClass *RndmcLcLBit_Dictionary();
6710  static void RndmcLcLBit_TClassManip(TClass*);
6711  static void *new_RndmcLcLBit(void *p = 0);
6712  static void *newArray_RndmcLcLBit(Long_t size, void *p);
6713  static void delete_RndmcLcLBit(void *p);
6714  static void deleteArray_RndmcLcLBit(void *p);
6715  static void destruct_RndmcLcLBit(void *p);
6716 
6717  // Function generating the singleton type initializer
6718  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Bit*)
6719  {
6720  ::Rndm::Bit *ptr = 0;
6721  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Bit));
6722  static ::ROOT::TGenericClassInfo
6723  instance("Rndm::Bit", "GaudiKernel/RndmGenerators.h", 301,
6724  typeid(::Rndm::Bit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6725  &RndmcLcLBit_Dictionary, isa_proxy, 4,
6726  sizeof(::Rndm::Bit) );
6727  instance.SetNew(&new_RndmcLcLBit);
6728  instance.SetNewArray(&newArray_RndmcLcLBit);
6729  instance.SetDelete(&delete_RndmcLcLBit);
6730  instance.SetDeleteArray(&deleteArray_RndmcLcLBit);
6731  instance.SetDestructor(&destruct_RndmcLcLBit);
6732  return &instance;
6733  }
6734  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Bit*)
6735  {
6736  return GenerateInitInstanceLocal((::Rndm::Bit*)0);
6737  }
6738  // Static variable to force the class initialization
6739  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Bit*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6740 
6741  // Dictionary for non-ClassDef classes
6742  static TClass *RndmcLcLBit_Dictionary() {
6743  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Bit*)0x0)->GetClass();
6744  RndmcLcLBit_TClassManip(theClass);
6745  return theClass;
6746  }
6747 
6748  static void RndmcLcLBit_TClassManip(TClass* ){
6749  }
6750 
6751 } // end of namespace ROOT
6752 
6753 namespace ROOT {
6754  static TClass *RndmcLcLDefinedPdf_Dictionary();
6755  static void RndmcLcLDefinedPdf_TClassManip(TClass*);
6756  static void delete_RndmcLcLDefinedPdf(void *p);
6757  static void deleteArray_RndmcLcLDefinedPdf(void *p);
6758  static void destruct_RndmcLcLDefinedPdf(void *p);
6759 
6760  // Function generating the singleton type initializer
6761  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::DefinedPdf*)
6762  {
6763  ::Rndm::DefinedPdf *ptr = 0;
6764  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::DefinedPdf));
6765  static ::ROOT::TGenericClassInfo
6766  instance("Rndm::DefinedPdf", "GaudiKernel/RndmGenerators.h", 330,
6767  typeid(::Rndm::DefinedPdf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6768  &RndmcLcLDefinedPdf_Dictionary, isa_proxy, 4,
6769  sizeof(::Rndm::DefinedPdf) );
6770  instance.SetDelete(&delete_RndmcLcLDefinedPdf);
6771  instance.SetDeleteArray(&deleteArray_RndmcLcLDefinedPdf);
6772  instance.SetDestructor(&destruct_RndmcLcLDefinedPdf);
6773  return &instance;
6774  }
6775  TGenericClassInfo *GenerateInitInstance(const ::Rndm::DefinedPdf*)
6776  {
6777  return GenerateInitInstanceLocal((::Rndm::DefinedPdf*)0);
6778  }
6779  // Static variable to force the class initialization
6780  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::DefinedPdf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6781 
6782  // Dictionary for non-ClassDef classes
6783  static TClass *RndmcLcLDefinedPdf_Dictionary() {
6784  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::DefinedPdf*)0x0)->GetClass();
6785  RndmcLcLDefinedPdf_TClassManip(theClass);
6786  return theClass;
6787  }
6788 
6789  static void RndmcLcLDefinedPdf_TClassManip(TClass* ){
6790  }
6791 
6792 } // end of namespace ROOT
6793 
6794 namespace ROOT {
6795  static TClass *RndmcLcLGaussianTail_Dictionary();
6796  static void RndmcLcLGaussianTail_TClassManip(TClass*);
6797  static void delete_RndmcLcLGaussianTail(void *p);
6798  static void deleteArray_RndmcLcLGaussianTail(void *p);
6799  static void destruct_RndmcLcLGaussianTail(void *p);
6800 
6801  // Function generating the singleton type initializer
6802  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::GaussianTail*)
6803  {
6804  ::Rndm::GaussianTail *ptr = 0;
6805  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::GaussianTail));
6806  static ::ROOT::TGenericClassInfo
6807  instance("Rndm::GaussianTail", "GaudiKernel/RndmGenerators.h", 358,
6808  typeid(::Rndm::GaussianTail), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6809  &RndmcLcLGaussianTail_Dictionary, isa_proxy, 4,
6810  sizeof(::Rndm::GaussianTail) );
6811  instance.SetDelete(&delete_RndmcLcLGaussianTail);
6812  instance.SetDeleteArray(&deleteArray_RndmcLcLGaussianTail);
6813  instance.SetDestructor(&destruct_RndmcLcLGaussianTail);
6814  return &instance;
6815  }
6816  TGenericClassInfo *GenerateInitInstance(const ::Rndm::GaussianTail*)
6817  {
6818  return GenerateInitInstanceLocal((::Rndm::GaussianTail*)0);
6819  }
6820  // Static variable to force the class initialization
6821  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::GaussianTail*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6822 
6823  // Dictionary for non-ClassDef classes
6824  static TClass *RndmcLcLGaussianTail_Dictionary() {
6825  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::GaussianTail*)0x0)->GetClass();
6826  RndmcLcLGaussianTail_TClassManip(theClass);
6827  return theClass;
6828  }
6829 
6830  static void RndmcLcLGaussianTail_TClassManip(TClass* ){
6831  }
6832 
6833 } // end of namespace ROOT
6834 
6835 namespace ROOT {
6836  static TClass *RndmcLcLNumbers_Dictionary();
6837  static void RndmcLcLNumbers_TClassManip(TClass*);
6838  static void *new_RndmcLcLNumbers(void *p = 0);
6839  static void *newArray_RndmcLcLNumbers(Long_t size, void *p);
6840  static void delete_RndmcLcLNumbers(void *p);
6841  static void deleteArray_RndmcLcLNumbers(void *p);
6842  static void destruct_RndmcLcLNumbers(void *p);
6843 
6844  // Function generating the singleton type initializer
6845  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Numbers*)
6846  {
6847  ::Rndm::Numbers *ptr = 0;
6848  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Numbers));
6849  static ::ROOT::TGenericClassInfo
6850  instance("Rndm::Numbers", "GaudiKernel/RndmGenerators.h", 396,
6851  typeid(::Rndm::Numbers), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6852  &RndmcLcLNumbers_Dictionary, isa_proxy, 4,
6853  sizeof(::Rndm::Numbers) );
6854  instance.SetNew(&new_RndmcLcLNumbers);
6855  instance.SetNewArray(&newArray_RndmcLcLNumbers);
6856  instance.SetDelete(&delete_RndmcLcLNumbers);
6857  instance.SetDeleteArray(&deleteArray_RndmcLcLNumbers);
6858  instance.SetDestructor(&destruct_RndmcLcLNumbers);
6859  return &instance;
6860  }
6861  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Numbers*)
6862  {
6863  return GenerateInitInstanceLocal((::Rndm::Numbers*)0);
6864  }
6865  // Static variable to force the class initialization
6866  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Numbers*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6867 
6868  // Dictionary for non-ClassDef classes
6869  static TClass *RndmcLcLNumbers_Dictionary() {
6870  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Numbers*)0x0)->GetClass();
6871  RndmcLcLNumbers_TClassManip(theClass);
6872  return theClass;
6873  }
6874 
6875  static void RndmcLcLNumbers_TClassManip(TClass* ){
6876  }
6877 
6878 } // end of namespace ROOT
6879 
6880 namespace ROOT {
6881  static TClass *SmartRefVectorlEDataObjectgR_Dictionary();
6882  static void SmartRefVectorlEDataObjectgR_TClassManip(TClass*);
6883  static void *new_SmartRefVectorlEDataObjectgR(void *p = 0);
6884  static void *newArray_SmartRefVectorlEDataObjectgR(Long_t size, void *p);
6885  static void delete_SmartRefVectorlEDataObjectgR(void *p);
6886  static void deleteArray_SmartRefVectorlEDataObjectgR(void *p);
6887  static void destruct_SmartRefVectorlEDataObjectgR(void *p);
6888 
6889  // Function generating the singleton type initializer
6890  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<DataObject>*)
6891  {
6892  ::SmartRefVector<DataObject> *ptr = 0;
6893  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<DataObject>));
6894  static ::ROOT::TGenericClassInfo
6895  instance("SmartRefVector<DataObject>", "GaudiKernel/SmartRefVector.h", 55,
6896  typeid(::SmartRefVector<DataObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6897  &SmartRefVectorlEDataObjectgR_Dictionary, isa_proxy, 4,
6898  sizeof(::SmartRefVector<DataObject>) );
6899  instance.SetNew(&new_SmartRefVectorlEDataObjectgR);
6900  instance.SetNewArray(&newArray_SmartRefVectorlEDataObjectgR);
6901  instance.SetDelete(&delete_SmartRefVectorlEDataObjectgR);
6902  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEDataObjectgR);
6903  instance.SetDestructor(&destruct_SmartRefVectorlEDataObjectgR);
6904  return &instance;
6905  }
6906  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<DataObject>*)
6907  {
6908  return GenerateInitInstanceLocal((::SmartRefVector<DataObject>*)0);
6909  }
6910  // Static variable to force the class initialization
6911  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<DataObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6912 
6913  // Dictionary for non-ClassDef classes
6914  static TClass *SmartRefVectorlEDataObjectgR_Dictionary() {
6915  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<DataObject>*)0x0)->GetClass();
6916  SmartRefVectorlEDataObjectgR_TClassManip(theClass);
6917  return theClass;
6918  }
6919 
6920  static void SmartRefVectorlEDataObjectgR_TClassManip(TClass* ){
6921  }
6922 
6923 } // end of namespace ROOT
6924 
6925 namespace ROOT {
6926  static TClass *SmartRefVectorlEContainedObjectgR_Dictionary();
6927  static void SmartRefVectorlEContainedObjectgR_TClassManip(TClass*);
6928  static void *new_SmartRefVectorlEContainedObjectgR(void *p = 0);
6929  static void *newArray_SmartRefVectorlEContainedObjectgR(Long_t size, void *p);
6930  static void delete_SmartRefVectorlEContainedObjectgR(void *p);
6931  static void deleteArray_SmartRefVectorlEContainedObjectgR(void *p);
6932  static void destruct_SmartRefVectorlEContainedObjectgR(void *p);
6933 
6934  // Function generating the singleton type initializer
6935  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<ContainedObject>*)
6936  {
6937  ::SmartRefVector<ContainedObject> *ptr = 0;
6938  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<ContainedObject>));
6939  static ::ROOT::TGenericClassInfo
6940  instance("SmartRefVector<ContainedObject>", "GaudiKernel/SmartRefVector.h", 55,
6941  typeid(::SmartRefVector<ContainedObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6942  &SmartRefVectorlEContainedObjectgR_Dictionary, isa_proxy, 4,
6943  sizeof(::SmartRefVector<ContainedObject>) );
6944  instance.SetNew(&new_SmartRefVectorlEContainedObjectgR);
6945  instance.SetNewArray(&newArray_SmartRefVectorlEContainedObjectgR);
6946  instance.SetDelete(&delete_SmartRefVectorlEContainedObjectgR);
6947  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEContainedObjectgR);
6948  instance.SetDestructor(&destruct_SmartRefVectorlEContainedObjectgR);
6949  return &instance;
6950  }
6951  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<ContainedObject>*)
6952  {
6953  return GenerateInitInstanceLocal((::SmartRefVector<ContainedObject>*)0);
6954  }
6955  // Static variable to force the class initialization
6956  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<ContainedObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6957 
6958  // Dictionary for non-ClassDef classes
6959  static TClass *SmartRefVectorlEContainedObjectgR_Dictionary() {
6960  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<ContainedObject>*)0x0)->GetClass();
6961  SmartRefVectorlEContainedObjectgR_TClassManip(theClass);
6962  return theClass;
6963  }
6964 
6965  static void SmartRefVectorlEContainedObjectgR_TClassManip(TClass* ){
6966  }
6967 
6968 } // end of namespace ROOT
6969 
6970 namespace ROOT {
6971  static TClass *SmartRefVectorlEObjectContainerBasegR_Dictionary();
6972  static void SmartRefVectorlEObjectContainerBasegR_TClassManip(TClass*);
6973  static void *new_SmartRefVectorlEObjectContainerBasegR(void *p = 0);
6974  static void *newArray_SmartRefVectorlEObjectContainerBasegR(Long_t size, void *p);
6975  static void delete_SmartRefVectorlEObjectContainerBasegR(void *p);
6976  static void deleteArray_SmartRefVectorlEObjectContainerBasegR(void *p);
6977  static void destruct_SmartRefVectorlEObjectContainerBasegR(void *p);
6978 
6979  // Function generating the singleton type initializer
6980  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<ObjectContainerBase>*)
6981  {
6982  ::SmartRefVector<ObjectContainerBase> *ptr = 0;
6983  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<ObjectContainerBase>));
6984  static ::ROOT::TGenericClassInfo
6985  instance("SmartRefVector<ObjectContainerBase>", "GaudiKernel/SmartRefVector.h", 55,
6986  typeid(::SmartRefVector<ObjectContainerBase>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6987  &SmartRefVectorlEObjectContainerBasegR_Dictionary, isa_proxy, 4,
6988  sizeof(::SmartRefVector<ObjectContainerBase>) );
6989  instance.SetNew(&new_SmartRefVectorlEObjectContainerBasegR);
6990  instance.SetNewArray(&newArray_SmartRefVectorlEObjectContainerBasegR);
6991  instance.SetDelete(&delete_SmartRefVectorlEObjectContainerBasegR);
6992  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEObjectContainerBasegR);
6993  instance.SetDestructor(&destruct_SmartRefVectorlEObjectContainerBasegR);
6994  return &instance;
6995  }
6996  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<ObjectContainerBase>*)
6997  {
6998  return GenerateInitInstanceLocal((::SmartRefVector<ObjectContainerBase>*)0);
6999  }
7000  // Static variable to force the class initialization
7001  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<ObjectContainerBase>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7002 
7003  // Dictionary for non-ClassDef classes
7004  static TClass *SmartRefVectorlEObjectContainerBasegR_Dictionary() {
7005  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<ObjectContainerBase>*)0x0)->GetClass();
7006  SmartRefVectorlEObjectContainerBasegR_TClassManip(theClass);
7007  return theClass;
7008  }
7009 
7010  static void SmartRefVectorlEObjectContainerBasegR_TClassManip(TClass* ){
7011  }
7012 
7013 } // end of namespace ROOT
7014 
7015 namespace ROOT {
7016  static TClass *SmartRefVectorlEKeyedObjectlEintgRsPgR_Dictionary();
7017  static void SmartRefVectorlEKeyedObjectlEintgRsPgR_TClassManip(TClass*);
7018  static void *new_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p = 0);
7019  static void *newArray_SmartRefVectorlEKeyedObjectlEintgRsPgR(Long_t size, void *p);
7020  static void delete_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p);
7021  static void deleteArray_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p);
7022  static void destruct_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p);
7023 
7024  // Function generating the singleton type initializer
7025  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<KeyedObject<int> >*)
7026  {
7027  ::SmartRefVector<KeyedObject<int> > *ptr = 0;
7028  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<KeyedObject<int> >));
7029  static ::ROOT::TGenericClassInfo
7030  instance("SmartRefVector<KeyedObject<int> >", "GaudiKernel/SmartRefVector.h", 55,
7031  typeid(::SmartRefVector<KeyedObject<int> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7032  &SmartRefVectorlEKeyedObjectlEintgRsPgR_Dictionary, isa_proxy, 4,
7033  sizeof(::SmartRefVector<KeyedObject<int> >) );
7034  instance.SetNew(&new_SmartRefVectorlEKeyedObjectlEintgRsPgR);
7035  instance.SetNewArray(&newArray_SmartRefVectorlEKeyedObjectlEintgRsPgR);
7036  instance.SetDelete(&delete_SmartRefVectorlEKeyedObjectlEintgRsPgR);
7037  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEKeyedObjectlEintgRsPgR);
7038  instance.SetDestructor(&destruct_SmartRefVectorlEKeyedObjectlEintgRsPgR);
7039  return &instance;
7040  }
7041  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<KeyedObject<int> >*)
7042  {
7043  return GenerateInitInstanceLocal((::SmartRefVector<KeyedObject<int> >*)0);
7044  }
7045  // Static variable to force the class initialization
7046  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<int> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7047 
7048  // Dictionary for non-ClassDef classes
7049  static TClass *SmartRefVectorlEKeyedObjectlEintgRsPgR_Dictionary() {
7050  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<int> >*)0x0)->GetClass();
7051  SmartRefVectorlEKeyedObjectlEintgRsPgR_TClassManip(theClass);
7052  return theClass;
7053  }
7054 
7055  static void SmartRefVectorlEKeyedObjectlEintgRsPgR_TClassManip(TClass* ){
7056  }
7057 
7058 } // end of namespace ROOT
7059 
7060 namespace ROOT {
7061  static TClass *SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR_Dictionary();
7062  static void SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR_TClassManip(TClass*);
7063  static void *new_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p = 0);
7064  static void *newArray_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(Long_t size, void *p);
7065  static void delete_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p);
7066  static void deleteArray_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p);
7067  static void destruct_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p);
7068 
7069  // Function generating the singleton type initializer
7070  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<KeyedObject<unsigned int> >*)
7071  {
7072  ::SmartRefVector<KeyedObject<unsigned int> > *ptr = 0;
7073  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<KeyedObject<unsigned int> >));
7074  static ::ROOT::TGenericClassInfo
7075  instance("SmartRefVector<KeyedObject<unsigned int> >", "GaudiKernel/SmartRefVector.h", 55,
7076  typeid(::SmartRefVector<KeyedObject<unsigned int> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7077  &SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR_Dictionary, isa_proxy, 4,
7078  sizeof(::SmartRefVector<KeyedObject<unsigned int> >) );
7079  instance.SetNew(&new_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR);
7080  instance.SetNewArray(&newArray_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR);
7081  instance.SetDelete(&delete_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR);
7082  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR);
7083  instance.SetDestructor(&destruct_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR);
7084  return &instance;
7085  }
7086  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<KeyedObject<unsigned int> >*)
7087  {
7088  return GenerateInitInstanceLocal((::SmartRefVector<KeyedObject<unsigned int> >*)0);
7089  }
7090  // Static variable to force the class initialization
7091  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<unsigned int> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7092 
7093  // Dictionary for non-ClassDef classes
7094  static TClass *SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR_Dictionary() {
7095  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<unsigned int> >*)0x0)->GetClass();
7096  SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR_TClassManip(theClass);
7097  return theClass;
7098  }
7099 
7100  static void SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR_TClassManip(TClass* ){
7101  }
7102 
7103 } // end of namespace ROOT
7104 
7105 namespace ROOT {
7106  static TClass *SmartRefVectorlEKeyedObjectlElonggRsPgR_Dictionary();
7107  static void SmartRefVectorlEKeyedObjectlElonggRsPgR_TClassManip(TClass*);
7108  static void *new_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p = 0);
7109  static void *newArray_SmartRefVectorlEKeyedObjectlElonggRsPgR(Long_t size, void *p);
7110  static void delete_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p);
7111  static void deleteArray_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p);
7112  static void destruct_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p);
7113 
7114  // Function generating the singleton type initializer
7115  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<KeyedObject<long> >*)
7116  {
7117  ::SmartRefVector<KeyedObject<long> > *ptr = 0;
7118  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<KeyedObject<long> >));
7119  static ::ROOT::TGenericClassInfo
7120  instance("SmartRefVector<KeyedObject<long> >", "GaudiKernel/SmartRefVector.h", 55,
7121  typeid(::SmartRefVector<KeyedObject<long> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7122  &SmartRefVectorlEKeyedObjectlElonggRsPgR_Dictionary, isa_proxy, 4,
7123  sizeof(::SmartRefVector<KeyedObject<long> >) );
7124  instance.SetNew(&new_SmartRefVectorlEKeyedObjectlElonggRsPgR);
7125  instance.SetNewArray(&newArray_SmartRefVectorlEKeyedObjectlElonggRsPgR);
7126  instance.SetDelete(&delete_SmartRefVectorlEKeyedObjectlElonggRsPgR);
7127  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEKeyedObjectlElonggRsPgR);
7128  instance.SetDestructor(&destruct_SmartRefVectorlEKeyedObjectlElonggRsPgR);
7129  return &instance;
7130  }
7131  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<KeyedObject<long> >*)
7132  {
7133  return GenerateInitInstanceLocal((::SmartRefVector<KeyedObject<long> >*)0);
7134  }
7135  // Static variable to force the class initialization
7136  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<long> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7137 
7138  // Dictionary for non-ClassDef classes
7139  static TClass *SmartRefVectorlEKeyedObjectlElonggRsPgR_Dictionary() {
7140  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<long> >*)0x0)->GetClass();
7141  SmartRefVectorlEKeyedObjectlElonggRsPgR_TClassManip(theClass);
7142  return theClass;
7143  }
7144 
7145  static void SmartRefVectorlEKeyedObjectlElonggRsPgR_TClassManip(TClass* ){
7146  }
7147 
7148 } // end of namespace ROOT
7149 
7150 namespace ROOT {
7151  static TClass *SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR_Dictionary();
7152  static void SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR_TClassManip(TClass*);
7153  static void *new_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p = 0);
7154  static void *newArray_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(Long_t size, void *p);
7155  static void delete_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p);
7156  static void deleteArray_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p);
7157  static void destruct_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p);
7158 
7159  // Function generating the singleton type initializer
7160  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<KeyedObject<unsigned long> >*)
7161  {
7162  ::SmartRefVector<KeyedObject<unsigned long> > *ptr = 0;
7163  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<KeyedObject<unsigned long> >));
7164  static ::ROOT::TGenericClassInfo
7165  instance("SmartRefVector<KeyedObject<unsigned long> >", "GaudiKernel/SmartRefVector.h", 55,
7166  typeid(::SmartRefVector<KeyedObject<unsigned long> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7167  &SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR_Dictionary, isa_proxy, 4,
7168  sizeof(::SmartRefVector<KeyedObject<unsigned long> >) );
7169  instance.SetNew(&new_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR);
7170  instance.SetNewArray(&newArray_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR);
7171  instance.SetDelete(&delete_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR);
7172  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR);
7173  instance.SetDestructor(&destruct_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR);
7174  return &instance;
7175  }
7176  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<KeyedObject<unsigned long> >*)
7177  {
7178  return GenerateInitInstanceLocal((::SmartRefVector<KeyedObject<unsigned long> >*)0);
7179  }
7180  // Static variable to force the class initialization
7181  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<unsigned long> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7182 
7183  // Dictionary for non-ClassDef classes
7184  static TClass *SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR_Dictionary() {
7185  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<unsigned long> >*)0x0)->GetClass();
7186  SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR_TClassManip(theClass);
7187  return theClass;
7188  }
7189 
7190  static void SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR_TClassManip(TClass* ){
7191  }
7192 
7193 } // end of namespace ROOT
7194 
7195 namespace ROOT {
7196  static TClass *GaudicLcLTime_Dictionary();
7197  static void GaudicLcLTime_TClassManip(TClass*);
7198  static void *new_GaudicLcLTime(void *p = 0);
7199  static void *newArray_GaudicLcLTime(Long_t size, void *p);
7200  static void delete_GaudicLcLTime(void *p);
7201  static void deleteArray_GaudicLcLTime(void *p);
7202  static void destruct_GaudicLcLTime(void *p);
7203 
7204  // Function generating the singleton type initializer
7205  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Time*)
7206  {
7207  ::Gaudi::Time *ptr = 0;
7208  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Time));
7209  static ::ROOT::TGenericClassInfo
7210  instance("Gaudi::Time", "GaudiKernel/Time.h", 237,
7211  typeid(::Gaudi::Time), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7212  &GaudicLcLTime_Dictionary, isa_proxy, 4,
7213  sizeof(::Gaudi::Time) );
7214  instance.SetNew(&new_GaudicLcLTime);
7215  instance.SetNewArray(&newArray_GaudicLcLTime);
7216  instance.SetDelete(&delete_GaudicLcLTime);
7217  instance.SetDeleteArray(&deleteArray_GaudicLcLTime);
7218  instance.SetDestructor(&destruct_GaudicLcLTime);
7219  return &instance;
7220  }
7221  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Time*)
7222  {
7223  return GenerateInitInstanceLocal((::Gaudi::Time*)0);
7224  }
7225  // Static variable to force the class initialization
7226  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Time*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7227 
7228  // Dictionary for non-ClassDef classes
7229  static TClass *GaudicLcLTime_Dictionary() {
7230  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Time*)0x0)->GetClass();
7231  GaudicLcLTime_TClassManip(theClass);
7232  return theClass;
7233  }
7234 
7235  static void GaudicLcLTime_TClassManip(TClass* ){
7236  }
7237 
7238 } // end of namespace ROOT
7239 
7240 namespace ROOT {
7241  static TClass *DataObjectHandleBase_Dictionary();
7242  static void DataObjectHandleBase_TClassManip(TClass*);
7243  static void delete_DataObjectHandleBase(void *p);
7244  static void deleteArray_DataObjectHandleBase(void *p);
7245  static void destruct_DataObjectHandleBase(void *p);
7246 
7247  // Function generating the singleton type initializer
7248  static TGenericClassInfo *GenerateInitInstanceLocal(const ::DataObjectHandleBase*)
7249  {
7250  ::DataObjectHandleBase *ptr = 0;
7251  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::DataObjectHandleBase));
7252  static ::ROOT::TGenericClassInfo
7253  instance("DataObjectHandleBase", "GaudiKernel/DataObjectHandleBase.h", 25,
7254  typeid(::DataObjectHandleBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7255  &DataObjectHandleBase_Dictionary, isa_proxy, 4,
7256  sizeof(::DataObjectHandleBase) );
7257  instance.SetDelete(&delete_DataObjectHandleBase);
7258  instance.SetDeleteArray(&deleteArray_DataObjectHandleBase);
7259  instance.SetDestructor(&destruct_DataObjectHandleBase);
7260  return &instance;
7261  }
7262  TGenericClassInfo *GenerateInitInstance(const ::DataObjectHandleBase*)
7263  {
7264  return GenerateInitInstanceLocal((::DataObjectHandleBase*)0);
7265  }
7266  // Static variable to force the class initialization
7267  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DataObjectHandleBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7268 
7269  // Dictionary for non-ClassDef classes
7270  static TClass *DataObjectHandleBase_Dictionary() {
7271  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::DataObjectHandleBase*)0x0)->GetClass();
7272  DataObjectHandleBase_TClassManip(theClass);
7273  return theClass;
7274  }
7275 
7276  static void DataObjectHandleBase_TClassManip(TClass* ){
7277  }
7278 
7279 } // end of namespace ROOT
7280 
7281 namespace ROOT {
7282  static TClass *IAddressCreator_Dictionary();
7283  static void IAddressCreator_TClassManip(TClass*);
7284  static void delete_IAddressCreator(void *p);
7285  static void deleteArray_IAddressCreator(void *p);
7286  static void destruct_IAddressCreator(void *p);
7287 
7288  // Function generating the singleton type initializer
7289  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAddressCreator*)
7290  {
7291  ::IAddressCreator *ptr = 0;
7292  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAddressCreator));
7293  static ::ROOT::TGenericClassInfo
7294  instance("IAddressCreator", "GaudiKernel/IAddressCreator.h", 28,
7295  typeid(::IAddressCreator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7296  &IAddressCreator_Dictionary, isa_proxy, 4,
7297  sizeof(::IAddressCreator) );
7298  instance.SetDelete(&delete_IAddressCreator);
7299  instance.SetDeleteArray(&deleteArray_IAddressCreator);
7300  instance.SetDestructor(&destruct_IAddressCreator);
7301  return &instance;
7302  }
7303  TGenericClassInfo *GenerateInitInstance(const ::IAddressCreator*)
7304  {
7305  return GenerateInitInstanceLocal((::IAddressCreator*)0);
7306  }
7307  // Static variable to force the class initialization
7308  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAddressCreator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7309 
7310  // Dictionary for non-ClassDef classes
7311  static TClass *IAddressCreator_Dictionary() {
7312  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAddressCreator*)0x0)->GetClass();
7313  IAddressCreator_TClassManip(theClass);
7314  return theClass;
7315  }
7316 
7317  static void IAddressCreator_TClassManip(TClass* ){
7318  }
7319 
7320 } // end of namespace ROOT
7321 
7322 namespace ROOT {
7323  static TClass *IAlgManager_Dictionary();
7324  static void IAlgManager_TClassManip(TClass*);
7325  static void delete_IAlgManager(void *p);
7326  static void deleteArray_IAlgManager(void *p);
7327  static void destruct_IAlgManager(void *p);
7328 
7329  // Function generating the singleton type initializer
7330  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAlgManager*)
7331  {
7332  ::IAlgManager *ptr = 0;
7333  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAlgManager));
7334  static ::ROOT::TGenericClassInfo
7335  instance("IAlgManager", "GaudiKernel/IAlgManager.h", 27,
7336  typeid(::IAlgManager), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7337  &IAlgManager_Dictionary, isa_proxy, 4,
7338  sizeof(::IAlgManager) );
7339  instance.SetDelete(&delete_IAlgManager);
7340  instance.SetDeleteArray(&deleteArray_IAlgManager);
7341  instance.SetDestructor(&destruct_IAlgManager);
7342  return &instance;
7343  }
7344  TGenericClassInfo *GenerateInitInstance(const ::IAlgManager*)
7345  {
7346  return GenerateInitInstanceLocal((::IAlgManager*)0);
7347  }
7348  // Static variable to force the class initialization
7349  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAlgManager*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7350 
7351  // Dictionary for non-ClassDef classes
7352  static TClass *IAlgManager_Dictionary() {
7353  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAlgManager*)0x0)->GetClass();
7354  IAlgManager_TClassManip(theClass);
7355  return theClass;
7356  }
7357 
7358  static void IAlgManager_TClassManip(TClass* ){
7359  }
7360 
7361 } // end of namespace ROOT
7362 
7363 namespace ROOT {
7364  static TClass *IAppMgrUI_Dictionary();
7365  static void IAppMgrUI_TClassManip(TClass*);
7366  static void delete_IAppMgrUI(void *p);
7367  static void deleteArray_IAppMgrUI(void *p);
7368  static void destruct_IAppMgrUI(void *p);
7369 
7370  // Function generating the singleton type initializer
7371  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAppMgrUI*)
7372  {
7373  ::IAppMgrUI *ptr = 0;
7374  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAppMgrUI));
7375  static ::ROOT::TGenericClassInfo
7376  instance("IAppMgrUI", "GaudiKernel/IAppMgrUI.h", 20,
7377  typeid(::IAppMgrUI), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7378  &IAppMgrUI_Dictionary, isa_proxy, 4,
7379  sizeof(::IAppMgrUI) );
7380  instance.SetDelete(&delete_IAppMgrUI);
7381  instance.SetDeleteArray(&deleteArray_IAppMgrUI);
7382  instance.SetDestructor(&destruct_IAppMgrUI);
7383  return &instance;
7384  }
7385  TGenericClassInfo *GenerateInitInstance(const ::IAppMgrUI*)
7386  {
7387  return GenerateInitInstanceLocal((::IAppMgrUI*)0);
7388  }
7389  // Static variable to force the class initialization
7390  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAppMgrUI*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7391 
7392  // Dictionary for non-ClassDef classes
7393  static TClass *IAppMgrUI_Dictionary() {
7394  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAppMgrUI*)0x0)->GetClass();
7395  IAppMgrUI_TClassManip(theClass);
7396  return theClass;
7397  }
7398 
7399  static void IAppMgrUI_TClassManip(TClass* ){
7400  }
7401 
7402 } // end of namespace ROOT
7403 
7404 namespace ROOT {
7405  static TClass *IClassInfo_Dictionary();
7406  static void IClassInfo_TClassManip(TClass*);
7407  static void delete_IClassInfo(void *p);
7408  static void deleteArray_IClassInfo(void *p);
7409  static void destruct_IClassInfo(void *p);
7410 
7411  // Function generating the singleton type initializer
7412  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IClassInfo*)
7413  {
7414  ::IClassInfo *ptr = 0;
7415  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IClassInfo));
7416  static ::ROOT::TGenericClassInfo
7417  instance("IClassInfo", "GaudiKernel/IClassInfo.h", 12,
7418  typeid(::IClassInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7419  &IClassInfo_Dictionary, isa_proxy, 4,
7420  sizeof(::IClassInfo) );
7421  instance.SetDelete(&delete_IClassInfo);
7422  instance.SetDeleteArray(&deleteArray_IClassInfo);
7423  instance.SetDestructor(&destruct_IClassInfo);
7424  return &instance;
7425  }
7426  TGenericClassInfo *GenerateInitInstance(const ::IClassInfo*)
7427  {
7428  return GenerateInitInstanceLocal((::IClassInfo*)0);
7429  }
7430  // Static variable to force the class initialization
7431  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IClassInfo*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7432 
7433  // Dictionary for non-ClassDef classes
7434  static TClass *IClassInfo_Dictionary() {
7435  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IClassInfo*)0x0)->GetClass();
7436  IClassInfo_TClassManip(theClass);
7437  return theClass;
7438  }
7439 
7440  static void IClassInfo_TClassManip(TClass* ){
7441  }
7442 
7443 } // end of namespace ROOT
7444 
7445 namespace ROOT {
7446  static TClass *IClassManager_Dictionary();
7447  static void IClassManager_TClassManip(TClass*);
7448  static void delete_IClassManager(void *p);
7449  static void deleteArray_IClassManager(void *p);
7450  static void destruct_IClassManager(void *p);
7451 
7452  // Function generating the singleton type initializer
7453  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IClassManager*)
7454  {
7455  ::IClassManager *ptr = 0;
7456  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IClassManager));
7457  static ::ROOT::TGenericClassInfo
7458  instance("IClassManager", "GaudiKernel/IClassManager.h", 18,
7459  typeid(::IClassManager), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7460  &IClassManager_Dictionary, isa_proxy, 4,
7461  sizeof(::IClassManager) );
7462  instance.SetDelete(&delete_IClassManager);
7463  instance.SetDeleteArray(&deleteArray_IClassManager);
7464  instance.SetDestructor(&destruct_IClassManager);
7465  return &instance;
7466  }
7467  TGenericClassInfo *GenerateInitInstance(const ::IClassManager*)
7468  {
7469  return GenerateInitInstanceLocal((::IClassManager*)0);
7470  }
7471  // Static variable to force the class initialization
7472  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IClassManager*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7473 
7474  // Dictionary for non-ClassDef classes
7475  static TClass *IClassManager_Dictionary() {
7476  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IClassManager*)0x0)->GetClass();
7477  IClassManager_TClassManip(theClass);
7478  return theClass;
7479  }
7480 
7481  static void IClassManager_TClassManip(TClass* ){
7482  }
7483 
7484 } // end of namespace ROOT
7485 
7486 namespace ROOT {
7487  static TClass *ICounterSummarySvc_Dictionary();
7488  static void ICounterSummarySvc_TClassManip(TClass*);
7489  static void delete_ICounterSummarySvc(void *p);
7490  static void deleteArray_ICounterSummarySvc(void *p);
7491  static void destruct_ICounterSummarySvc(void *p);
7492 
7493  // Function generating the singleton type initializer
7494  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ICounterSummarySvc*)
7495  {
7496  ::ICounterSummarySvc *ptr = 0;
7497  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ICounterSummarySvc));
7498  static ::ROOT::TGenericClassInfo
7499  instance("ICounterSummarySvc", "GaudiKernel/ICounterSummarySvc.h", 36,
7500  typeid(::ICounterSummarySvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7501  &ICounterSummarySvc_Dictionary, isa_proxy, 4,
7502  sizeof(::ICounterSummarySvc) );
7503  instance.SetDelete(&delete_ICounterSummarySvc);
7504  instance.SetDeleteArray(&deleteArray_ICounterSummarySvc);
7505  instance.SetDestructor(&destruct_ICounterSummarySvc);
7506  return &instance;
7507  }
7508  TGenericClassInfo *GenerateInitInstance(const ::ICounterSummarySvc*)
7509  {
7510  return GenerateInitInstanceLocal((::ICounterSummarySvc*)0);
7511  }
7512  // Static variable to force the class initialization
7513  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ICounterSummarySvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7514 
7515  // Dictionary for non-ClassDef classes
7516  static TClass *ICounterSummarySvc_Dictionary() {
7517  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ICounterSummarySvc*)0x0)->GetClass();
7518  ICounterSummarySvc_TClassManip(theClass);
7519  return theClass;
7520  }
7521 
7522  static void ICounterSummarySvc_TClassManip(TClass* ){
7523  }
7524 
7525 } // end of namespace ROOT
7526 
7527 namespace ROOT {
7528  static TClass *ICounterSvc_Dictionary();
7529  static void ICounterSvc_TClassManip(TClass*);
7530  static void delete_ICounterSvc(void *p);
7531  static void deleteArray_ICounterSvc(void *p);
7532  static void destruct_ICounterSvc(void *p);
7533 
7534  // Function generating the singleton type initializer
7535  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ICounterSvc*)
7536  {
7537  ::ICounterSvc *ptr = 0;
7538  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ICounterSvc));
7539  static ::ROOT::TGenericClassInfo
7540  instance("ICounterSvc", "GaudiKernel/ICounterSvc.h", 75,
7541  typeid(::ICounterSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7542  &ICounterSvc_Dictionary, isa_proxy, 4,
7543  sizeof(::ICounterSvc) );
7544  instance.SetDelete(&delete_ICounterSvc);
7545  instance.SetDeleteArray(&deleteArray_ICounterSvc);
7546  instance.SetDestructor(&destruct_ICounterSvc);
7547  return &instance;
7548  }
7549  TGenericClassInfo *GenerateInitInstance(const ::ICounterSvc*)
7550  {
7551  return GenerateInitInstanceLocal((::ICounterSvc*)0);
7552  }
7553  // Static variable to force the class initialization
7554  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ICounterSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7555 
7556  // Dictionary for non-ClassDef classes
7557  static TClass *ICounterSvc_Dictionary() {
7558  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ICounterSvc*)0x0)->GetClass();
7559  ICounterSvc_TClassManip(theClass);
7560  return theClass;
7561  }
7562 
7563  static void ICounterSvc_TClassManip(TClass* ){
7564  }
7565 
7566 } // end of namespace ROOT
7567 
7568 namespace ROOT {
7569  static TClass *IDataManagerSvc_Dictionary();
7570  static void IDataManagerSvc_TClassManip(TClass*);
7571  static void delete_IDataManagerSvc(void *p);
7572  static void deleteArray_IDataManagerSvc(void *p);
7573  static void destruct_IDataManagerSvc(void *p);
7574 
7575  // Function generating the singleton type initializer
7576  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDataManagerSvc*)
7577  {
7578  ::IDataManagerSvc *ptr = 0;
7579  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDataManagerSvc));
7580  static ::ROOT::TGenericClassInfo
7581  instance("IDataManagerSvc", "GaudiKernel/IDataManagerSvc.h", 45,
7582  typeid(::IDataManagerSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7583  &IDataManagerSvc_Dictionary, isa_proxy, 4,
7584  sizeof(::IDataManagerSvc) );
7585  instance.SetDelete(&delete_IDataManagerSvc);
7586  instance.SetDeleteArray(&deleteArray_IDataManagerSvc);
7587  instance.SetDestructor(&destruct_IDataManagerSvc);
7588  return &instance;
7589  }
7590  TGenericClassInfo *GenerateInitInstance(const ::IDataManagerSvc*)
7591  {
7592  return GenerateInitInstanceLocal((::IDataManagerSvc*)0);
7593  }
7594  // Static variable to force the class initialization
7595  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDataManagerSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7596 
7597  // Dictionary for non-ClassDef classes
7598  static TClass *IDataManagerSvc_Dictionary() {
7599  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDataManagerSvc*)0x0)->GetClass();
7600  IDataManagerSvc_TClassManip(theClass);
7601  return theClass;
7602  }
7603 
7604  static void IDataManagerSvc_TClassManip(TClass* ){
7605  }
7606 
7607 } // end of namespace ROOT
7608 
7609 namespace ROOT {
7610  static TClass *IDataSourceMgr_Dictionary();
7611  static void IDataSourceMgr_TClassManip(TClass*);
7612  static void delete_IDataSourceMgr(void *p);
7613  static void deleteArray_IDataSourceMgr(void *p);
7614  static void destruct_IDataSourceMgr(void *p);
7615 
7616  // Function generating the singleton type initializer
7617  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDataSourceMgr*)
7618  {
7619  ::IDataSourceMgr *ptr = 0;
7620  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDataSourceMgr));
7621  static ::ROOT::TGenericClassInfo
7622  instance("IDataSourceMgr", "GaudiKernel/IDataSourceMgr.h", 14,
7623  typeid(::IDataSourceMgr), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7624  &IDataSourceMgr_Dictionary, isa_proxy, 4,
7625  sizeof(::IDataSourceMgr) );
7626  instance.SetDelete(&delete_IDataSourceMgr);
7627  instance.SetDeleteArray(&deleteArray_IDataSourceMgr);
7628  instance.SetDestructor(&destruct_IDataSourceMgr);
7629  return &instance;
7630  }
7631  TGenericClassInfo *GenerateInitInstance(const ::IDataSourceMgr*)
7632  {
7633  return GenerateInitInstanceLocal((::IDataSourceMgr*)0);
7634  }
7635  // Static variable to force the class initialization
7636  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDataSourceMgr*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7637 
7638  // Dictionary for non-ClassDef classes
7639  static TClass *IDataSourceMgr_Dictionary() {
7640  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDataSourceMgr*)0x0)->GetClass();
7641  IDataSourceMgr_TClassManip(theClass);
7642  return theClass;
7643  }
7644 
7645  static void IDataSourceMgr_TClassManip(TClass* ){
7646  }
7647 
7648 } // end of namespace ROOT
7649 
7650 namespace ROOT {
7651  static TClass *IDataStoreAgent_Dictionary();
7652  static void IDataStoreAgent_TClassManip(TClass*);
7653  static void delete_IDataStoreAgent(void *p);
7654  static void deleteArray_IDataStoreAgent(void *p);
7655  static void destruct_IDataStoreAgent(void *p);
7656 
7657  // Function generating the singleton type initializer
7658  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDataStoreAgent*)
7659  {
7660  ::IDataStoreAgent *ptr = 0;
7661  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDataStoreAgent));
7662  static ::ROOT::TGenericClassInfo
7663  instance("IDataStoreAgent", "GaudiKernel/IDataStoreAgent.h", 16,
7664  typeid(::IDataStoreAgent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7665  &IDataStoreAgent_Dictionary, isa_proxy, 4,
7666  sizeof(::IDataStoreAgent) );
7667  instance.SetDelete(&delete_IDataStoreAgent);
7668  instance.SetDeleteArray(&deleteArray_IDataStoreAgent);
7669  instance.SetDestructor(&destruct_IDataStoreAgent);
7670  return &instance;
7671  }
7672  TGenericClassInfo *GenerateInitInstance(const ::IDataStoreAgent*)
7673  {
7674  return GenerateInitInstanceLocal((::IDataStoreAgent*)0);
7675  }
7676  // Static variable to force the class initialization
7677  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDataStoreAgent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7678 
7679  // Dictionary for non-ClassDef classes
7680  static TClass *IDataStoreAgent_Dictionary() {
7681  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDataStoreAgent*)0x0)->GetClass();
7682  IDataStoreAgent_TClassManip(theClass);
7683  return theClass;
7684  }
7685 
7686  static void IDataStoreAgent_TClassManip(TClass* ){
7687  }
7688 
7689 } // end of namespace ROOT
7690 
7691 namespace ROOT {
7692  static TClass *IDataStoreLeaves_Dictionary();
7693  static void IDataStoreLeaves_TClassManip(TClass*);
7694  static void delete_IDataStoreLeaves(void *p);
7695  static void deleteArray_IDataStoreLeaves(void *p);
7696  static void destruct_IDataStoreLeaves(void *p);
7697 
7698  // Function generating the singleton type initializer
7699  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDataStoreLeaves*)
7700  {
7701  ::IDataStoreLeaves *ptr = 0;
7702  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDataStoreLeaves));
7703  static ::ROOT::TGenericClassInfo
7704  instance("IDataStoreLeaves", "GaudiKernel/IDataStoreLeaves.h", 15,
7705  typeid(::IDataStoreLeaves), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7706  &IDataStoreLeaves_Dictionary, isa_proxy, 4,
7707  sizeof(::IDataStoreLeaves) );
7708  instance.SetDelete(&delete_IDataStoreLeaves);
7709  instance.SetDeleteArray(&deleteArray_IDataStoreLeaves);
7710  instance.SetDestructor(&destruct_IDataStoreLeaves);
7711  return &instance;
7712  }
7713  TGenericClassInfo *GenerateInitInstance(const ::IDataStoreLeaves*)
7714  {
7715  return GenerateInitInstanceLocal((::IDataStoreLeaves*)0);
7716  }
7717  // Static variable to force the class initialization
7718  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDataStoreLeaves*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7719 
7720  // Dictionary for non-ClassDef classes
7721  static TClass *IDataStoreLeaves_Dictionary() {
7722  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDataStoreLeaves*)0x0)->GetClass();
7723  IDataStoreLeaves_TClassManip(theClass);
7724  return theClass;
7725  }
7726 
7727  static void IDataStoreLeaves_TClassManip(TClass* ){
7728  }
7729 
7730 } // end of namespace ROOT
7731 
7732 namespace ROOT {
7733  static TClass *IDetDataSvc_Dictionary();
7734  static void IDetDataSvc_TClassManip(TClass*);
7735  static void delete_IDetDataSvc(void *p);
7736  static void deleteArray_IDetDataSvc(void *p);
7737  static void destruct_IDetDataSvc(void *p);
7738 
7739  // Function generating the singleton type initializer
7740  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDetDataSvc*)
7741  {
7742  ::IDetDataSvc *ptr = 0;
7743  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDetDataSvc));
7744  static ::ROOT::TGenericClassInfo
7745  instance("IDetDataSvc", "GaudiKernel/IDetDataSvc.h", 23,
7746  typeid(::IDetDataSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7747  &IDetDataSvc_Dictionary, isa_proxy, 4,
7748  sizeof(::IDetDataSvc) );
7749  instance.SetDelete(&delete_IDetDataSvc);
7750  instance.SetDeleteArray(&deleteArray_IDetDataSvc);
7751  instance.SetDestructor(&destruct_IDetDataSvc);
7752  return &instance;
7753  }
7754  TGenericClassInfo *GenerateInitInstance(const ::IDetDataSvc*)
7755  {
7756  return GenerateInitInstanceLocal((::IDetDataSvc*)0);
7757  }
7758  // Static variable to force the class initialization
7759  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDetDataSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7760 
7761  // Dictionary for non-ClassDef classes
7762  static TClass *IDetDataSvc_Dictionary() {
7763  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDetDataSvc*)0x0)->GetClass();
7764  IDetDataSvc_TClassManip(theClass);
7765  return theClass;
7766  }
7767 
7768  static void IDetDataSvc_TClassManip(TClass* ){
7769  }
7770 
7771 } // end of namespace ROOT
7772 
7773 namespace ROOT {
7774  static TClass *IEventProcessor_Dictionary();
7775  static void IEventProcessor_TClassManip(TClass*);
7776  static void delete_IEventProcessor(void *p);
7777  static void deleteArray_IEventProcessor(void *p);
7778  static void destruct_IEventProcessor(void *p);
7779 
7780  // Function generating the singleton type initializer
7781  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IEventProcessor*)
7782  {
7783  ::IEventProcessor *ptr = 0;
7784  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IEventProcessor));
7785  static ::ROOT::TGenericClassInfo
7786  instance("IEventProcessor", "GaudiKernel/IEventProcessor.h", 16,
7787  typeid(::IEventProcessor), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7788  &IEventProcessor_Dictionary, isa_proxy, 4,
7789  sizeof(::IEventProcessor) );
7790  instance.SetDelete(&delete_IEventProcessor);
7791  instance.SetDeleteArray(&deleteArray_IEventProcessor);
7792  instance.SetDestructor(&destruct_IEventProcessor);
7793  return &instance;
7794  }
7795  TGenericClassInfo *GenerateInitInstance(const ::IEventProcessor*)
7796  {
7797  return GenerateInitInstanceLocal((::IEventProcessor*)0);
7798  }
7799  // Static variable to force the class initialization
7800  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IEventProcessor*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7801 
7802  // Dictionary for non-ClassDef classes
7803  static TClass *IEventProcessor_Dictionary() {
7804  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IEventProcessor*)0x0)->GetClass();
7805  IEventProcessor_TClassManip(theClass);
7806  return theClass;
7807  }
7808 
7809  static void IEventProcessor_TClassManip(TClass* ){
7810  }
7811 
7812 } // end of namespace ROOT
7813 
7814 namespace ROOT {
7815  static TClass *IEventTimeDecoder_Dictionary();
7816  static void IEventTimeDecoder_TClassManip(TClass*);
7817  static void delete_IEventTimeDecoder(void *p);
7818  static void deleteArray_IEventTimeDecoder(void *p);
7819  static void destruct_IEventTimeDecoder(void *p);
7820 
7821  // Function generating the singleton type initializer
7822  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IEventTimeDecoder*)
7823  {
7824  ::IEventTimeDecoder *ptr = 0;
7825  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IEventTimeDecoder));
7826  static ::ROOT::TGenericClassInfo
7827  instance("IEventTimeDecoder", "GaudiKernel/IEventTimeDecoder.h", 19,
7828  typeid(::IEventTimeDecoder), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7829  &IEventTimeDecoder_Dictionary, isa_proxy, 4,
7830  sizeof(::IEventTimeDecoder) );
7831  instance.SetDelete(&delete_IEventTimeDecoder);
7832  instance.SetDeleteArray(&deleteArray_IEventTimeDecoder);
7833  instance.SetDestructor(&destruct_IEventTimeDecoder);
7834  return &instance;
7835  }
7836  TGenericClassInfo *GenerateInitInstance(const ::IEventTimeDecoder*)
7837  {
7838  return GenerateInitInstanceLocal((::IEventTimeDecoder*)0);
7839  }
7840  // Static variable to force the class initialization
7841  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IEventTimeDecoder*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7842 
7843  // Dictionary for non-ClassDef classes
7844  static TClass *IEventTimeDecoder_Dictionary() {
7845  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IEventTimeDecoder*)0x0)->GetClass();
7846  IEventTimeDecoder_TClassManip(theClass);
7847  return theClass;
7848  }
7849 
7850  static void IEventTimeDecoder_TClassManip(TClass* ){
7851  }
7852 
7853 } // end of namespace ROOT
7854 
7855 namespace ROOT {
7856  static TClass *IHistorySvc_Dictionary();
7857  static void IHistorySvc_TClassManip(TClass*);
7858  static void delete_IHistorySvc(void *p);
7859  static void deleteArray_IHistorySvc(void *p);
7860  static void destruct_IHistorySvc(void *p);
7861 
7862  // Function generating the singleton type initializer
7863  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IHistorySvc*)
7864  {
7865  ::IHistorySvc *ptr = 0;
7866  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IHistorySvc));
7867  static ::ROOT::TGenericClassInfo
7868  instance("IHistorySvc", "GaudiKernel/IHistorySvc.h", 31,
7869  typeid(::IHistorySvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7870  &IHistorySvc_Dictionary, isa_proxy, 4,
7871  sizeof(::IHistorySvc) );
7872  instance.SetDelete(&delete_IHistorySvc);
7873  instance.SetDeleteArray(&deleteArray_IHistorySvc);
7874  instance.SetDestructor(&destruct_IHistorySvc);
7875  return &instance;
7876  }
7877  TGenericClassInfo *GenerateInitInstance(const ::IHistorySvc*)
7878  {
7879  return GenerateInitInstanceLocal((::IHistorySvc*)0);
7880  }
7881  // Static variable to force the class initialization
7882  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IHistorySvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7883 
7884  // Dictionary for non-ClassDef classes
7885  static TClass *IHistorySvc_Dictionary() {
7886  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IHistorySvc*)0x0)->GetClass();
7887  IHistorySvc_TClassManip(theClass);
7888  return theClass;
7889  }
7890 
7891  static void IHistorySvc_TClassManip(TClass* ){
7892  }
7893 
7894 } // end of namespace ROOT
7895 
7896 namespace ROOT {
7897  static TClass *IIncidentListener_Dictionary();
7898  static void IIncidentListener_TClassManip(TClass*);
7899  static void delete_IIncidentListener(void *p);
7900  static void deleteArray_IIncidentListener(void *p);
7901  static void destruct_IIncidentListener(void *p);
7902 
7903  // Function generating the singleton type initializer
7904  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IIncidentListener*)
7905  {
7906  ::IIncidentListener *ptr = 0;
7907  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IIncidentListener));
7908  static ::ROOT::TGenericClassInfo
7909  instance("IIncidentListener", "GaudiKernel/IIncidentListener.h", 15,
7910  typeid(::IIncidentListener), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7911  &IIncidentListener_Dictionary, isa_proxy, 4,
7912  sizeof(::IIncidentListener) );
7913  instance.SetDelete(&delete_IIncidentListener);
7914  instance.SetDeleteArray(&deleteArray_IIncidentListener);
7915  instance.SetDestructor(&destruct_IIncidentListener);
7916  return &instance;
7917  }
7918  TGenericClassInfo *GenerateInitInstance(const ::IIncidentListener*)
7919  {
7920  return GenerateInitInstanceLocal((::IIncidentListener*)0);
7921  }
7922  // Static variable to force the class initialization
7923  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IIncidentListener*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7924 
7925  // Dictionary for non-ClassDef classes
7926  static TClass *IIncidentListener_Dictionary() {
7927  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IIncidentListener*)0x0)->GetClass();
7928  IIncidentListener_TClassManip(theClass);
7929  return theClass;
7930  }
7931 
7932  static void IIncidentListener_TClassManip(TClass* ){
7933  }
7934 
7935 } // end of namespace ROOT
7936 
7937 namespace ROOT {
7938  static TClass *IInspectable_Dictionary();
7939  static void IInspectable_TClassManip(TClass*);
7940  static void delete_IInspectable(void *p);
7941  static void deleteArray_IInspectable(void *p);
7942  static void destruct_IInspectable(void *p);
7943 
7944  // Function generating the singleton type initializer
7945  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IInspectable*)
7946  {
7947  ::IInspectable *ptr = 0;
7948  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IInspectable));
7949  static ::ROOT::TGenericClassInfo
7950  instance("IInspectable", "GaudiKernel/IInspectable.h", 17,
7951  typeid(::IInspectable), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7952  &IInspectable_Dictionary, isa_proxy, 4,
7953  sizeof(::IInspectable) );
7954  instance.SetDelete(&delete_IInspectable);
7955  instance.SetDeleteArray(&deleteArray_IInspectable);
7956  instance.SetDestructor(&destruct_IInspectable);
7957  return &instance;
7958  }
7959  TGenericClassInfo *GenerateInitInstance(const ::IInspectable*)
7960  {
7961  return GenerateInitInstanceLocal((::IInspectable*)0);
7962  }
7963  // Static variable to force the class initialization
7964  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IInspectable*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7965 
7966  // Dictionary for non-ClassDef classes
7967  static TClass *IInspectable_Dictionary() {
7968  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IInspectable*)0x0)->GetClass();
7969  IInspectable_TClassManip(theClass);
7970  return theClass;
7971  }
7972 
7973  static void IInspectable_TClassManip(TClass* ){
7974  }
7975 
7976 } // end of namespace ROOT
7977 
7978 namespace ROOT {
7979  static TClass *IInspector_Dictionary();
7980  static void IInspector_TClassManip(TClass*);
7981  static void delete_IInspector(void *p);
7982  static void deleteArray_IInspector(void *p);
7983  static void destruct_IInspector(void *p);
7984 
7985  // Function generating the singleton type initializer
7986  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IInspector*)
7987  {
7988  ::IInspector *ptr = 0;
7989  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IInspector));
7990  static ::ROOT::TGenericClassInfo
7991  instance("IInspector", "GaudiKernel/IInspector.h", 15,
7992  typeid(::IInspector), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7993  &IInspector_Dictionary, isa_proxy, 4,
7994  sizeof(::IInspector) );
7995  instance.SetDelete(&delete_IInspector);
7996  instance.SetDeleteArray(&deleteArray_IInspector);
7997  instance.SetDestructor(&destruct_IInspector);
7998  return &instance;
7999  }
8000  TGenericClassInfo *GenerateInitInstance(const ::IInspector*)
8001  {
8002  return GenerateInitInstanceLocal((::IInspector*)0);
8003  }
8004  // Static variable to force the class initialization
8005  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IInspector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8006 
8007  // Dictionary for non-ClassDef classes
8008  static TClass *IInspector_Dictionary() {
8009  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IInspector*)0x0)->GetClass();
8010  IInspector_TClassManip(theClass);
8011  return theClass;
8012  }
8013 
8014  static void IInspector_TClassManip(TClass* ){
8015  }
8016 
8017 } // end of namespace ROOT
8018 
8019 namespace ROOT {
8020  static TClass *IMagneticFieldSvc_Dictionary();
8021  static void IMagneticFieldSvc_TClassManip(TClass*);
8022  static void delete_IMagneticFieldSvc(void *p);
8023  static void deleteArray_IMagneticFieldSvc(void *p);
8024  static void destruct_IMagneticFieldSvc(void *p);
8025 
8026  // Function generating the singleton type initializer
8027  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IMagneticFieldSvc*)
8028  {
8029  ::IMagneticFieldSvc *ptr = 0;
8030  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IMagneticFieldSvc));
8031  static ::ROOT::TGenericClassInfo
8032  instance("IMagneticFieldSvc", "GaudiKernel/IMagneticFieldSvc.h", 37,
8033  typeid(::IMagneticFieldSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8034  &IMagneticFieldSvc_Dictionary, isa_proxy, 4,
8035  sizeof(::IMagneticFieldSvc) );
8036  instance.SetDelete(&delete_IMagneticFieldSvc);
8037  instance.SetDeleteArray(&deleteArray_IMagneticFieldSvc);
8038  instance.SetDestructor(&destruct_IMagneticFieldSvc);
8039  return &instance;
8040  }
8041  TGenericClassInfo *GenerateInitInstance(const ::IMagneticFieldSvc*)
8042  {
8043  return GenerateInitInstanceLocal((::IMagneticFieldSvc*)0);
8044  }
8045  // Static variable to force the class initialization
8046  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IMagneticFieldSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8047 
8048  // Dictionary for non-ClassDef classes
8049  static TClass *IMagneticFieldSvc_Dictionary() {
8050  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IMagneticFieldSvc*)0x0)->GetClass();
8051  IMagneticFieldSvc_TClassManip(theClass);
8052  return theClass;
8053  }
8054 
8055  static void IMagneticFieldSvc_TClassManip(TClass* ){
8056  }
8057 
8058 } // end of namespace ROOT
8059 
8060 namespace ROOT {
8061  static TClass *IPartPropSvc_Dictionary();
8062  static void IPartPropSvc_TClassManip(TClass*);
8063  static void delete_IPartPropSvc(void *p);
8064  static void deleteArray_IPartPropSvc(void *p);
8065  static void destruct_IPartPropSvc(void *p);
8066 
8067  // Function generating the singleton type initializer
8068  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IPartPropSvc*)
8069  {
8070  ::IPartPropSvc *ptr = 0;
8071  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IPartPropSvc));
8072  static ::ROOT::TGenericClassInfo
8073  instance("IPartPropSvc", "GaudiKernel/IPartPropSvc.h", 21,
8074  typeid(::IPartPropSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8075  &IPartPropSvc_Dictionary, isa_proxy, 4,
8076  sizeof(::IPartPropSvc) );
8077  instance.SetDelete(&delete_IPartPropSvc);
8078  instance.SetDeleteArray(&deleteArray_IPartPropSvc);
8079  instance.SetDestructor(&destruct_IPartPropSvc);
8080  return &instance;
8081  }
8082  TGenericClassInfo *GenerateInitInstance(const ::IPartPropSvc*)
8083  {
8084  return GenerateInitInstanceLocal((::IPartPropSvc*)0);
8085  }
8086  // Static variable to force the class initialization
8087  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IPartPropSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8088 
8089  // Dictionary for non-ClassDef classes
8090  static TClass *IPartPropSvc_Dictionary() {
8091  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IPartPropSvc*)0x0)->GetClass();
8092  IPartPropSvc_TClassManip(theClass);
8093  return theClass;
8094  }
8095 
8096  static void IPartPropSvc_TClassManip(TClass* ){
8097  }
8098 
8099 } // end of namespace ROOT
8100 
8101 namespace ROOT {
8102  static TClass *IParticlePropertySvc_Dictionary();
8103  static void IParticlePropertySvc_TClassManip(TClass*);
8104  static void delete_IParticlePropertySvc(void *p);
8105  static void deleteArray_IParticlePropertySvc(void *p);
8106  static void destruct_IParticlePropertySvc(void *p);
8107 
8108  // Function generating the singleton type initializer
8109  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IParticlePropertySvc*)
8110  {
8111  ::IParticlePropertySvc *ptr = 0;
8112  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IParticlePropertySvc));
8113  static ::ROOT::TGenericClassInfo
8114  instance("IParticlePropertySvc", "GaudiKernel/IParticlePropertySvc.h", 18,
8115  typeid(::IParticlePropertySvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8116  &IParticlePropertySvc_Dictionary, isa_proxy, 4,
8117  sizeof(::IParticlePropertySvc) );
8118  instance.SetDelete(&delete_IParticlePropertySvc);
8119  instance.SetDeleteArray(&deleteArray_IParticlePropertySvc);
8120  instance.SetDestructor(&destruct_IParticlePropertySvc);
8121  return &instance;
8122  }
8123  TGenericClassInfo *GenerateInitInstance(const ::IParticlePropertySvc*)
8124  {
8125  return GenerateInitInstanceLocal((::IParticlePropertySvc*)0);
8126  }
8127  // Static variable to force the class initialization
8128  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IParticlePropertySvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8129 
8130  // Dictionary for non-ClassDef classes
8131  static TClass *IParticlePropertySvc_Dictionary() {
8132  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IParticlePropertySvc*)0x0)->GetClass();
8133  IParticlePropertySvc_TClassManip(theClass);
8134  return theClass;
8135  }
8136 
8137  static void IParticlePropertySvc_TClassManip(TClass* ){
8138  }
8139 
8140 } // end of namespace ROOT
8141 
8142 namespace ROOT {
8143  static TClass *IPartitionControl_Dictionary();
8144  static void IPartitionControl_TClassManip(TClass*);
8145  static void delete_IPartitionControl(void *p);
8146  static void deleteArray_IPartitionControl(void *p);
8147  static void destruct_IPartitionControl(void *p);
8148 
8149  // Function generating the singleton type initializer
8150  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IPartitionControl*)
8151  {
8152  ::IPartitionControl *ptr = 0;
8153  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IPartitionControl));
8154  static ::ROOT::TGenericClassInfo
8155  instance("IPartitionControl", "GaudiKernel/IPartitionControl.h", 66,
8156  typeid(::IPartitionControl), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8157  &IPartitionControl_Dictionary, isa_proxy, 4,
8158  sizeof(::IPartitionControl) );
8159  instance.SetDelete(&delete_IPartitionControl);
8160  instance.SetDeleteArray(&deleteArray_IPartitionControl);
8161  instance.SetDestructor(&destruct_IPartitionControl);
8162  return &instance;
8163  }
8164  TGenericClassInfo *GenerateInitInstance(const ::IPartitionControl*)
8165  {
8166  return GenerateInitInstanceLocal((::IPartitionControl*)0);
8167  }
8168  // Static variable to force the class initialization
8169  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IPartitionControl*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8170 
8171  // Dictionary for non-ClassDef classes
8172  static TClass *IPartitionControl_Dictionary() {
8173  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IPartitionControl*)0x0)->GetClass();
8174  IPartitionControl_TClassManip(theClass);
8175  return theClass;
8176  }
8177 
8178  static void IPartitionControl_TClassManip(TClass* ){
8179  }
8180 
8181 } // end of namespace ROOT
8182 
8183 namespace ROOT {
8184  static TClass *IPersistencySvc_Dictionary();
8185  static void IPersistencySvc_TClassManip(TClass*);
8186  static void delete_IPersistencySvc(void *p);
8187  static void deleteArray_IPersistencySvc(void *p);
8188  static void destruct_IPersistencySvc(void *p);
8189 
8190  // Function generating the singleton type initializer
8191  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IPersistencySvc*)
8192  {
8193  ::IPersistencySvc *ptr = 0;
8194  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IPersistencySvc));
8195  static ::ROOT::TGenericClassInfo
8196  instance("IPersistencySvc", "GaudiKernel/IPersistencySvc.h", 19,
8197  typeid(::IPersistencySvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8198  &IPersistencySvc_Dictionary, isa_proxy, 4,
8199  sizeof(::IPersistencySvc) );
8200  instance.SetDelete(&delete_IPersistencySvc);
8201  instance.SetDeleteArray(&deleteArray_IPersistencySvc);
8202  instance.SetDestructor(&destruct_IPersistencySvc);
8203  return &instance;
8204  }
8205  TGenericClassInfo *GenerateInitInstance(const ::IPersistencySvc*)
8206  {
8207  return GenerateInitInstanceLocal((::IPersistencySvc*)0);
8208  }
8209  // Static variable to force the class initialization
8210  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IPersistencySvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8211 
8212  // Dictionary for non-ClassDef classes
8213  static TClass *IPersistencySvc_Dictionary() {
8214  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IPersistencySvc*)0x0)->GetClass();
8215  IPersistencySvc_TClassManip(theClass);
8216  return theClass;
8217  }
8218 
8219  static void IPersistencySvc_TClassManip(TClass* ){
8220  }
8221 
8222 } // end of namespace ROOT
8223 
8224 namespace ROOT {
8225  static TClass *IRndmEngine_Dictionary();
8226  static void IRndmEngine_TClassManip(TClass*);
8227  static void delete_IRndmEngine(void *p);
8228  static void deleteArray_IRndmEngine(void *p);
8229  static void destruct_IRndmEngine(void *p);
8230 
8231  // Function generating the singleton type initializer
8232  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IRndmEngine*)
8233  {
8234  ::IRndmEngine *ptr = 0;
8235  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IRndmEngine));
8236  static ::ROOT::TGenericClassInfo
8237  instance("IRndmEngine", "GaudiKernel/IRndmEngine.h", 19,
8238  typeid(::IRndmEngine), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8239  &IRndmEngine_Dictionary, isa_proxy, 4,
8240  sizeof(::IRndmEngine) );
8241  instance.SetDelete(&delete_IRndmEngine);
8242  instance.SetDeleteArray(&deleteArray_IRndmEngine);
8243  instance.SetDestructor(&destruct_IRndmEngine);
8244  return &instance;
8245  }
8246  TGenericClassInfo *GenerateInitInstance(const ::IRndmEngine*)
8247  {
8248  return GenerateInitInstanceLocal((::IRndmEngine*)0);
8249  }
8250  // Static variable to force the class initialization
8251  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IRndmEngine*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8252 
8253  // Dictionary for non-ClassDef classes
8254  static TClass *IRndmEngine_Dictionary() {
8255  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IRndmEngine*)0x0)->GetClass();
8256  IRndmEngine_TClassManip(theClass);
8257  return theClass;
8258  }
8259 
8260  static void IRndmEngine_TClassManip(TClass* ){
8261  }
8262 
8263 } // end of namespace ROOT
8264 
8265 namespace ROOT {
8266  static TClass *IRunable_Dictionary();
8267  static void IRunable_TClassManip(TClass*);
8268  static void delete_IRunable(void *p);
8269  static void deleteArray_IRunable(void *p);
8270  static void destruct_IRunable(void *p);
8271 
8272  // Function generating the singleton type initializer
8273  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IRunable*)
8274  {
8275  ::IRunable *ptr = 0;
8276  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IRunable));
8277  static ::ROOT::TGenericClassInfo
8278  instance("IRunable", "GaudiKernel/IRunable.h", 18,
8279  typeid(::IRunable), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8280  &IRunable_Dictionary, isa_proxy, 4,
8281  sizeof(::IRunable) );
8282  instance.SetDelete(&delete_IRunable);
8283  instance.SetDeleteArray(&deleteArray_IRunable);
8284  instance.SetDestructor(&destruct_IRunable);
8285  return &instance;
8286  }
8287  TGenericClassInfo *GenerateInitInstance(const ::IRunable*)
8288  {
8289  return GenerateInitInstanceLocal((::IRunable*)0);
8290  }
8291  // Static variable to force the class initialization
8292  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IRunable*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8293 
8294  // Dictionary for non-ClassDef classes
8295  static TClass *IRunable_Dictionary() {
8296  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IRunable*)0x0)->GetClass();
8297  IRunable_TClassManip(theClass);
8298  return theClass;
8299  }
8300 
8301  static void IRunable_TClassManip(TClass* ){
8302  }
8303 
8304 } // end of namespace ROOT
8305 
8306 namespace ROOT {
8307  static TClass *ISelectStatement_Dictionary();
8308  static void ISelectStatement_TClassManip(TClass*);
8309  static void delete_ISelectStatement(void *p);
8310  static void deleteArray_ISelectStatement(void *p);
8311  static void destruct_ISelectStatement(void *p);
8312 
8313  // Function generating the singleton type initializer
8314  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ISelectStatement*)
8315  {
8316  ::ISelectStatement *ptr = 0;
8317  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ISelectStatement));
8318  static ::ROOT::TGenericClassInfo
8319  instance("ISelectStatement", "GaudiKernel/ISelectStatement.h", 32,
8320  typeid(::ISelectStatement), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8321  &ISelectStatement_Dictionary, isa_proxy, 4,
8322  sizeof(::ISelectStatement) );
8323  instance.SetDelete(&delete_ISelectStatement);
8324  instance.SetDeleteArray(&deleteArray_ISelectStatement);
8325  instance.SetDestructor(&destruct_ISelectStatement);
8326  return &instance;
8327  }
8328  TGenericClassInfo *GenerateInitInstance(const ::ISelectStatement*)
8329  {
8330  return GenerateInitInstanceLocal((::ISelectStatement*)0);
8331  }
8332  // Static variable to force the class initialization
8333  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ISelectStatement*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8334 
8335  // Dictionary for non-ClassDef classes
8336  static TClass *ISelectStatement_Dictionary() {
8337  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ISelectStatement*)0x0)->GetClass();
8338  ISelectStatement_TClassManip(theClass);
8339  return theClass;
8340  }
8341 
8342  static void ISelectStatement_TClassManip(TClass* ){
8343  }
8344 
8345 } // end of namespace ROOT
8346 
8347 namespace ROOT {
8348  static TClass *ISerialize_Dictionary();
8349  static void ISerialize_TClassManip(TClass*);
8350  static void delete_ISerialize(void *p);
8351  static void deleteArray_ISerialize(void *p);
8352  static void destruct_ISerialize(void *p);
8353 
8354  // Function generating the singleton type initializer
8355  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ISerialize*)
8356  {
8357  ::ISerialize *ptr = 0;
8358  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ISerialize));
8359  static ::ROOT::TGenericClassInfo
8360  instance("ISerialize", "GaudiKernel/ISerialize.h", 17,
8361  typeid(::ISerialize), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8362  &ISerialize_Dictionary, isa_proxy, 4,
8363  sizeof(::ISerialize) );
8364  instance.SetDelete(&delete_ISerialize);
8365  instance.SetDeleteArray(&deleteArray_ISerialize);
8366  instance.SetDestructor(&destruct_ISerialize);
8367  return &instance;
8368  }
8369  TGenericClassInfo *GenerateInitInstance(const ::ISerialize*)
8370  {
8371  return GenerateInitInstanceLocal((::ISerialize*)0);
8372  }
8373  // Static variable to force the class initialization
8374  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ISerialize*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8375 
8376  // Dictionary for non-ClassDef classes
8377  static TClass *ISerialize_Dictionary() {
8378  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ISerialize*)0x0)->GetClass();
8379  ISerialize_TClassManip(theClass);
8380  return theClass;
8381  }
8382 
8383  static void ISerialize_TClassManip(TClass* ){
8384  }
8385 
8386 } // end of namespace ROOT
8387 
8388 namespace ROOT {
8389  static TClass *IStagerSvc_Dictionary();
8390  static void IStagerSvc_TClassManip(TClass*);
8391  static void delete_IStagerSvc(void *p);
8392  static void deleteArray_IStagerSvc(void *p);
8393  static void destruct_IStagerSvc(void *p);
8394 
8395  // Function generating the singleton type initializer
8396  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IStagerSvc*)
8397  {
8398  ::IStagerSvc *ptr = 0;
8399  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IStagerSvc));
8400  static ::ROOT::TGenericClassInfo
8401  instance("IStagerSvc", "GaudiKernel/IStagerSvc.h", 11,
8402  typeid(::IStagerSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8403  &IStagerSvc_Dictionary, isa_proxy, 4,
8404  sizeof(::IStagerSvc) );
8405  instance.SetDelete(&delete_IStagerSvc);
8406  instance.SetDeleteArray(&deleteArray_IStagerSvc);
8407  instance.SetDestructor(&destruct_IStagerSvc);
8408  return &instance;
8409  }
8410  TGenericClassInfo *GenerateInitInstance(const ::IStagerSvc*)
8411  {
8412  return GenerateInitInstanceLocal((::IStagerSvc*)0);
8413  }
8414  // Static variable to force the class initialization
8415  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IStagerSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8416 
8417  // Dictionary for non-ClassDef classes
8418  static TClass *IStagerSvc_Dictionary() {
8419  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IStagerSvc*)0x0)->GetClass();
8420  IStagerSvc_TClassManip(theClass);
8421  return theClass;
8422  }
8423 
8424  static void IStagerSvc_TClassManip(TClass* ){
8425  }
8426 
8427 } // end of namespace ROOT
8428 
8429 namespace ROOT {
8430  static TClass *IStatusCodeSvc_Dictionary();
8431  static void IStatusCodeSvc_TClassManip(TClass*);
8432  static void delete_IStatusCodeSvc(void *p);
8433  static void deleteArray_IStatusCodeSvc(void *p);
8434  static void destruct_IStatusCodeSvc(void *p);
8435 
8436  // Function generating the singleton type initializer
8437  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IStatusCodeSvc*)
8438  {
8439  ::IStatusCodeSvc *ptr = 0;
8440  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IStatusCodeSvc));
8441  static ::ROOT::TGenericClassInfo
8442  instance("IStatusCodeSvc", "GaudiKernel/IStatusCodeSvc.h", 7,
8443  typeid(::IStatusCodeSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8444  &IStatusCodeSvc_Dictionary, isa_proxy, 4,
8445  sizeof(::IStatusCodeSvc) );
8446  instance.SetDelete(&delete_IStatusCodeSvc);
8447  instance.SetDeleteArray(&deleteArray_IStatusCodeSvc);
8448  instance.SetDestructor(&destruct_IStatusCodeSvc);
8449  return &instance;
8450  }
8451  TGenericClassInfo *GenerateInitInstance(const ::IStatusCodeSvc*)
8452  {
8453  return GenerateInitInstanceLocal((::IStatusCodeSvc*)0);
8454  }
8455  // Static variable to force the class initialization
8456  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IStatusCodeSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8457 
8458  // Dictionary for non-ClassDef classes
8459  static TClass *IStatusCodeSvc_Dictionary() {
8460  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IStatusCodeSvc*)0x0)->GetClass();
8461  IStatusCodeSvc_TClassManip(theClass);
8462  return theClass;
8463  }
8464 
8465  static void IStatusCodeSvc_TClassManip(TClass* ){
8466  }
8467 
8468 } // end of namespace ROOT
8469 
8470 namespace ROOT {
8471  static TClass *ITHistSvc_Dictionary();
8472  static void ITHistSvc_TClassManip(TClass*);
8473  static void delete_ITHistSvc(void *p);
8474  static void deleteArray_ITHistSvc(void *p);
8475  static void destruct_ITHistSvc(void *p);
8476 
8477  // Function generating the singleton type initializer
8478  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ITHistSvc*)
8479  {
8480  ::ITHistSvc *ptr = 0;
8481  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ITHistSvc));
8482  static ::ROOT::TGenericClassInfo
8483  instance("ITHistSvc", "GaudiKernel/ITHistSvc.h", 19,
8484  typeid(::ITHistSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8485  &ITHistSvc_Dictionary, isa_proxy, 4,
8486  sizeof(::ITHistSvc) );
8487  instance.SetDelete(&delete_ITHistSvc);
8488  instance.SetDeleteArray(&deleteArray_ITHistSvc);
8489  instance.SetDestructor(&destruct_ITHistSvc);
8490  return &instance;
8491  }
8492  TGenericClassInfo *GenerateInitInstance(const ::ITHistSvc*)
8493  {
8494  return GenerateInitInstanceLocal((::ITHistSvc*)0);
8495  }
8496  // Static variable to force the class initialization
8497  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ITHistSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8498 
8499  // Dictionary for non-ClassDef classes
8500  static TClass *ITHistSvc_Dictionary() {
8501  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ITHistSvc*)0x0)->GetClass();
8502  ITHistSvc_TClassManip(theClass);
8503  return theClass;
8504  }
8505 
8506  static void ITHistSvc_TClassManip(TClass* ){
8507  }
8508 
8509 } // end of namespace ROOT
8510 
8511 namespace ROOT {
8512  static TClass *IUpdateManagerSvc_Dictionary();
8513  static void IUpdateManagerSvc_TClassManip(TClass*);
8514  static void delete_IUpdateManagerSvc(void *p);
8515  static void deleteArray_IUpdateManagerSvc(void *p);
8516  static void destruct_IUpdateManagerSvc(void *p);
8517 
8518  // Function generating the singleton type initializer
8519  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IUpdateManagerSvc*)
8520  {
8521  ::IUpdateManagerSvc *ptr = 0;
8522  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IUpdateManagerSvc));
8523  static ::ROOT::TGenericClassInfo
8524  instance("IUpdateManagerSvc", "GaudiKernel/IUpdateManagerSvc.h", 144,
8525  typeid(::IUpdateManagerSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8526  &IUpdateManagerSvc_Dictionary, isa_proxy, 4,
8527  sizeof(::IUpdateManagerSvc) );
8528  instance.SetDelete(&delete_IUpdateManagerSvc);
8529  instance.SetDeleteArray(&deleteArray_IUpdateManagerSvc);
8530  instance.SetDestructor(&destruct_IUpdateManagerSvc);
8531  return &instance;
8532  }
8533  TGenericClassInfo *GenerateInitInstance(const ::IUpdateManagerSvc*)
8534  {
8535  return GenerateInitInstanceLocal((::IUpdateManagerSvc*)0);
8536  }
8537  // Static variable to force the class initialization
8538  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IUpdateManagerSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8539 
8540  // Dictionary for non-ClassDef classes
8541  static TClass *IUpdateManagerSvc_Dictionary() {
8542  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IUpdateManagerSvc*)0x0)->GetClass();
8543  IUpdateManagerSvc_TClassManip(theClass);
8544  return theClass;
8545  }
8546 
8547  static void IUpdateManagerSvc_TClassManip(TClass* ){
8548  }
8549 
8550 } // end of namespace ROOT
8551 
8552 namespace ROOT {
8553  static TClass *IUpdateable_Dictionary();
8554  static void IUpdateable_TClassManip(TClass*);
8555  static void delete_IUpdateable(void *p);
8556  static void deleteArray_IUpdateable(void *p);
8557  static void destruct_IUpdateable(void *p);
8558 
8559  // Function generating the singleton type initializer
8560  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IUpdateable*)
8561  {
8562  ::IUpdateable *ptr = 0;
8563  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IUpdateable));
8564  static ::ROOT::TGenericClassInfo
8565  instance("IUpdateable", "GaudiKernel/IUpdateable.h", 15,
8566  typeid(::IUpdateable), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8567  &IUpdateable_Dictionary, isa_proxy, 4,
8568  sizeof(::IUpdateable) );
8569  instance.SetDelete(&delete_IUpdateable);
8570  instance.SetDeleteArray(&deleteArray_IUpdateable);
8571  instance.SetDestructor(&destruct_IUpdateable);
8572  return &instance;
8573  }
8574  TGenericClassInfo *GenerateInitInstance(const ::IUpdateable*)
8575  {
8576  return GenerateInitInstanceLocal((::IUpdateable*)0);
8577  }
8578  // Static variable to force the class initialization
8579  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IUpdateable*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8580 
8581  // Dictionary for non-ClassDef classes
8582  static TClass *IUpdateable_Dictionary() {
8583  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IUpdateable*)0x0)->GetClass();
8584  IUpdateable_TClassManip(theClass);
8585  return theClass;
8586  }
8587 
8588  static void IUpdateable_TClassManip(TClass* ){
8589  }
8590 
8591 } // end of namespace ROOT
8592 
8593 namespace ROOT {
8594  static TClass *IValidity_Dictionary();
8595  static void IValidity_TClassManip(TClass*);
8596  static void delete_IValidity(void *p);
8597  static void deleteArray_IValidity(void *p);
8598  static void destruct_IValidity(void *p);
8599 
8600  // Function generating the singleton type initializer
8601  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IValidity*)
8602  {
8603  ::IValidity *ptr = 0;
8604  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IValidity));
8605  static ::ROOT::TGenericClassInfo
8606  instance("IValidity", "GaudiKernel/IValidity.h", 12,
8607  typeid(::IValidity), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8608  &IValidity_Dictionary, isa_proxy, 4,
8609  sizeof(::IValidity) );
8610  instance.SetDelete(&delete_IValidity);
8611  instance.SetDeleteArray(&deleteArray_IValidity);
8612  instance.SetDestructor(&destruct_IValidity);
8613  return &instance;
8614  }
8615  TGenericClassInfo *GenerateInitInstance(const ::IValidity*)
8616  {
8617  return GenerateInitInstanceLocal((::IValidity*)0);
8618  }
8619  // Static variable to force the class initialization
8620  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IValidity*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8621 
8622  // Dictionary for non-ClassDef classes
8623  static TClass *IValidity_Dictionary() {
8624  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IValidity*)0x0)->GetClass();
8625  IValidity_TClassManip(theClass);
8626  return theClass;
8627  }
8628 
8629  static void IValidity_TClassManip(TClass* ){
8630  }
8631 
8632 } // end of namespace ROOT
8633 
8634 namespace ROOT {
8635  static TClass *IUpdateManagerSvccLcLPythonHelper_Dictionary();
8636  static void IUpdateManagerSvccLcLPythonHelper_TClassManip(TClass*);
8637  static void *new_IUpdateManagerSvccLcLPythonHelper(void *p = 0);
8638  static void *newArray_IUpdateManagerSvccLcLPythonHelper(Long_t size, void *p);
8639  static void delete_IUpdateManagerSvccLcLPythonHelper(void *p);
8640  static void deleteArray_IUpdateManagerSvccLcLPythonHelper(void *p);
8641  static void destruct_IUpdateManagerSvccLcLPythonHelper(void *p);
8642 
8643  // Function generating the singleton type initializer
8644  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IUpdateManagerSvc::PythonHelper*)
8645  {
8646  ::IUpdateManagerSvc::PythonHelper *ptr = 0;
8647  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IUpdateManagerSvc::PythonHelper));
8648  static ::ROOT::TGenericClassInfo
8649  instance("IUpdateManagerSvc::PythonHelper", "", 208,
8650  typeid(::IUpdateManagerSvc::PythonHelper), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8651  &IUpdateManagerSvccLcLPythonHelper_Dictionary, isa_proxy, 4,
8652  sizeof(::IUpdateManagerSvc::PythonHelper) );
8653  instance.SetNew(&new_IUpdateManagerSvccLcLPythonHelper);
8654  instance.SetNewArray(&newArray_IUpdateManagerSvccLcLPythonHelper);
8655  instance.SetDelete(&delete_IUpdateManagerSvccLcLPythonHelper);
8656  instance.SetDeleteArray(&deleteArray_IUpdateManagerSvccLcLPythonHelper);
8657  instance.SetDestructor(&destruct_IUpdateManagerSvccLcLPythonHelper);
8658  return &instance;
8659  }
8660  TGenericClassInfo *GenerateInitInstance(const ::IUpdateManagerSvc::PythonHelper*)
8661  {
8662  return GenerateInitInstanceLocal((::IUpdateManagerSvc::PythonHelper*)0);
8663  }
8664  // Static variable to force the class initialization
8665  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IUpdateManagerSvc::PythonHelper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8666 
8667  // Dictionary for non-ClassDef classes
8668  static TClass *IUpdateManagerSvccLcLPythonHelper_Dictionary() {
8669  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IUpdateManagerSvc::PythonHelper*)0x0)->GetClass();
8670  IUpdateManagerSvccLcLPythonHelper_TClassManip(theClass);
8671  return theClass;
8672  }
8673 
8674  static void IUpdateManagerSvccLcLPythonHelper_TClassManip(TClass* ){
8675  }
8676 
8677 } // end of namespace ROOT
8678 
8679 namespace ROOT {
8680  // Wrappers around operator new
8681  static void *new_StatusCode(void *p) {
8682  return p ? new(p) ::StatusCode : new ::StatusCode;
8683  }
8684  static void *newArray_StatusCode(Long_t nElements, void *p) {
8685  return p ? new(p) ::StatusCode[nElements] : new ::StatusCode[nElements];
8686  }
8687  // Wrapper around operator delete
8688  static void delete_StatusCode(void *p) {
8689  delete ((::StatusCode*)p);
8690  }
8691  static void deleteArray_StatusCode(void *p) {
8692  delete [] ((::StatusCode*)p);
8693  }
8694  static void destruct_StatusCode(void *p) {
8695  typedef ::StatusCode current_t;
8696  ((current_t*)p)->~current_t();
8697  }
8698 } // end of namespace ROOT for class ::StatusCode
8699 
8700 namespace ROOT {
8701  // Wrapper around operator delete
8702  static void delete_InterfaceID(void *p) {
8703  delete ((::InterfaceID*)p);
8704  }
8705  static void deleteArray_InterfaceID(void *p) {
8706  delete [] ((::InterfaceID*)p);
8707  }
8708  static void destruct_InterfaceID(void *p) {
8709  typedef ::InterfaceID current_t;
8710  ((current_t*)p)->~current_t();
8711  }
8712 } // end of namespace ROOT for class ::InterfaceID
8713 
8714 namespace ROOT {
8715  // Wrapper around operator delete
8716  static void delete_IInterface(void *p) {
8717  delete ((::IInterface*)p);
8718  }
8719  static void deleteArray_IInterface(void *p) {
8720  delete [] ((::IInterface*)p);
8721  }
8722  static void destruct_IInterface(void *p) {
8723  typedef ::IInterface current_t;
8724  ((current_t*)p)->~current_t();
8725  }
8726 } // end of namespace ROOT for class ::IInterface
8727 
8728 namespace ROOT {
8729  // Wrapper around operator delete
8730  static void delete_IMessageSvc(void *p) {
8731  delete ((::IMessageSvc*)p);
8732  }
8733  static void deleteArray_IMessageSvc(void *p) {
8734  delete [] ((::IMessageSvc*)p);
8735  }
8736  static void destruct_IMessageSvc(void *p) {
8737  typedef ::IMessageSvc current_t;
8738  ((current_t*)p)->~current_t();
8739  }
8740 } // end of namespace ROOT for class ::IMessageSvc
8741 
8742 namespace ROOT {
8743  // Wrapper around operator delete
8744  static void delete_INamedInterface(void *p) {
8745  delete ((::INamedInterface*)p);
8746  }
8747  static void deleteArray_INamedInterface(void *p) {
8748  delete [] ((::INamedInterface*)p);
8749  }
8750  static void destruct_INamedInterface(void *p) {
8751  typedef ::INamedInterface current_t;
8752  ((current_t*)p)->~current_t();
8753  }
8754 } // end of namespace ROOT for class ::INamedInterface
8755 
8756 namespace ROOT {
8757  // Wrapper around operator delete
8758  static void delete_IStateful(void *p) {
8759  delete ((::IStateful*)p);
8760  }
8761  static void deleteArray_IStateful(void *p) {
8762  delete [] ((::IStateful*)p);
8763  }
8764  static void destruct_IStateful(void *p) {
8765  typedef ::IStateful current_t;
8766  ((current_t*)p)->~current_t();
8767  }
8768 } // end of namespace ROOT for class ::IStateful
8769 
8770 namespace ROOT {
8771  // Wrapper around operator delete
8772  static void delete_IService(void *p) {
8773  delete ((::IService*)p);
8774  }
8775  static void deleteArray_IService(void *p) {
8776  delete [] ((::IService*)p);
8777  }
8778  static void destruct_IService(void *p) {
8779  typedef ::IService current_t;
8780  ((current_t*)p)->~current_t();
8781  }
8782 } // end of namespace ROOT for class ::IService
8783 
8784 namespace ROOT {
8785  // Wrappers around operator new
8786  static void *new_SmartIFlEIPropertygR(void *p) {
8787  return p ? new(p) ::SmartIF<IProperty> : new ::SmartIF<IProperty>;
8788  }
8789  static void *newArray_SmartIFlEIPropertygR(Long_t nElements, void *p) {
8790  return p ? new(p) ::SmartIF<IProperty>[nElements] : new ::SmartIF<IProperty>[nElements];
8791  }
8792  // Wrapper around operator delete
8793  static void delete_SmartIFlEIPropertygR(void *p) {
8794  delete ((::SmartIF<IProperty>*)p);
8795  }
8796  static void deleteArray_SmartIFlEIPropertygR(void *p) {
8797  delete [] ((::SmartIF<IProperty>*)p);
8798  }
8799  static void destruct_SmartIFlEIPropertygR(void *p) {
8800  typedef ::SmartIF<IProperty> current_t;
8801  ((current_t*)p)->~current_t();
8802  }
8803 } // end of namespace ROOT for class ::SmartIF<IProperty>
8804 
8805 namespace ROOT {
8806  // Wrappers around operator new
8807  static void *new_SmartIFlEIServicegR(void *p) {
8808  return p ? new(p) ::SmartIF<IService> : new ::SmartIF<IService>;
8809  }
8810  static void *newArray_SmartIFlEIServicegR(Long_t nElements, void *p) {
8811  return p ? new(p) ::SmartIF<IService>[nElements] : new ::SmartIF<IService>[nElements];
8812  }
8813  // Wrapper around operator delete
8814  static void delete_SmartIFlEIServicegR(void *p) {
8815  delete ((::SmartIF<IService>*)p);
8816  }
8817  static void deleteArray_SmartIFlEIServicegR(void *p) {
8818  delete [] ((::SmartIF<IService>*)p);
8819  }
8820  static void destruct_SmartIFlEIServicegR(void *p) {
8821  typedef ::SmartIF<IService> current_t;
8822  ((current_t*)p)->~current_t();
8823  }
8824 } // end of namespace ROOT for class ::SmartIF<IService>
8825 
8826 namespace ROOT {
8827  // Wrappers around operator new
8828  static void *new_SmartIFlEISvcLocatorgR(void *p) {
8829  return p ? new(p) ::SmartIF<ISvcLocator> : new ::SmartIF<ISvcLocator>;
8830  }
8831  static void *newArray_SmartIFlEISvcLocatorgR(Long_t nElements, void *p) {
8832  return p ? new(p) ::SmartIF<ISvcLocator>[nElements] : new ::SmartIF<ISvcLocator>[nElements];
8833  }
8834  // Wrapper around operator delete
8835  static void delete_SmartIFlEISvcLocatorgR(void *p) {
8836  delete ((::SmartIF<ISvcLocator>*)p);
8837  }
8838  static void deleteArray_SmartIFlEISvcLocatorgR(void *p) {
8839  delete [] ((::SmartIF<ISvcLocator>*)p);
8840  }
8841  static void destruct_SmartIFlEISvcLocatorgR(void *p) {
8842  typedef ::SmartIF<ISvcLocator> current_t;
8843  ((current_t*)p)->~current_t();
8844  }
8845 } // end of namespace ROOT for class ::SmartIF<ISvcLocator>
8846 
8847 namespace ROOT {
8848  // Wrappers around operator new
8849  static void *new_SmartIFlEIMessageSvcgR(void *p) {
8850  return p ? new(p) ::SmartIF<IMessageSvc> : new ::SmartIF<IMessageSvc>;
8851  }
8852  static void *newArray_SmartIFlEIMessageSvcgR(Long_t nElements, void *p) {
8853  return p ? new(p) ::SmartIF<IMessageSvc>[nElements] : new ::SmartIF<IMessageSvc>[nElements];
8854  }
8855  // Wrapper around operator delete
8856  static void delete_SmartIFlEIMessageSvcgR(void *p) {
8857  delete ((::SmartIF<IMessageSvc>*)p);
8858  }
8859  static void deleteArray_SmartIFlEIMessageSvcgR(void *p) {
8860  delete [] ((::SmartIF<IMessageSvc>*)p);
8861  }
8862  static void destruct_SmartIFlEIMessageSvcgR(void *p) {
8863  typedef ::SmartIF<IMessageSvc> current_t;
8864  ((current_t*)p)->~current_t();
8865  }
8866 } // end of namespace ROOT for class ::SmartIF<IMessageSvc>
8867 
8868 namespace ROOT {
8869  // Wrappers around operator new
8870  static void *new_SmartIFlEIDataProviderSvcgR(void *p) {
8871  return p ? new(p) ::SmartIF<IDataProviderSvc> : new ::SmartIF<IDataProviderSvc>;
8872  }
8873  static void *newArray_SmartIFlEIDataProviderSvcgR(Long_t nElements, void *p) {
8874  return p ? new(p) ::SmartIF<IDataProviderSvc>[nElements] : new ::SmartIF<IDataProviderSvc>[nElements];
8875  }
8876  // Wrapper around operator delete
8877  static void delete_SmartIFlEIDataProviderSvcgR(void *p) {
8878  delete ((::SmartIF<IDataProviderSvc>*)p);
8879  }
8880  static void deleteArray_SmartIFlEIDataProviderSvcgR(void *p) {
8881  delete [] ((::SmartIF<IDataProviderSvc>*)p);
8882  }
8883  static void destruct_SmartIFlEIDataProviderSvcgR(void *p) {
8884  typedef ::SmartIF<IDataProviderSvc> current_t;
8885  ((current_t*)p)->~current_t();
8886  }
8887 } // end of namespace ROOT for class ::SmartIF<IDataProviderSvc>
8888 
8889 namespace ROOT {
8890  // Wrappers around operator new
8891  static void *new_SmartIFlEIToolSvcgR(void *p) {
8892  return p ? new(p) ::SmartIF<IToolSvc> : new ::SmartIF<IToolSvc>;
8893  }
8894  static void *newArray_SmartIFlEIToolSvcgR(Long_t nElements, void *p) {
8895  return p ? new(p) ::SmartIF<IToolSvc>[nElements] : new ::SmartIF<IToolSvc>[nElements];
8896  }
8897  // Wrapper around operator delete
8898  static void delete_SmartIFlEIToolSvcgR(void *p) {
8899  delete ((::SmartIF<IToolSvc>*)p);
8900  }
8901  static void deleteArray_SmartIFlEIToolSvcgR(void *p) {
8902  delete [] ((::SmartIF<IToolSvc>*)p);
8903  }
8904  static void destruct_SmartIFlEIToolSvcgR(void *p) {
8905  typedef ::SmartIF<IToolSvc> current_t;
8906  ((current_t*)p)->~current_t();
8907  }
8908 } // end of namespace ROOT for class ::SmartIF<IToolSvc>
8909 
8910 namespace ROOT {
8911  // Wrappers around operator new
8912  static void *new_SmartIFlEIMonitorSvcgR(void *p) {
8913  return p ? new(p) ::SmartIF<IMonitorSvc> : new ::SmartIF<IMonitorSvc>;
8914  }
8915  static void *newArray_SmartIFlEIMonitorSvcgR(Long_t nElements, void *p) {
8916  return p ? new(p) ::SmartIF<IMonitorSvc>[nElements] : new ::SmartIF<IMonitorSvc>[nElements];
8917  }
8918  // Wrapper around operator delete
8919  static void delete_SmartIFlEIMonitorSvcgR(void *p) {
8920  delete ((::SmartIF<IMonitorSvc>*)p);
8921  }
8922  static void deleteArray_SmartIFlEIMonitorSvcgR(void *p) {
8923  delete [] ((::SmartIF<IMonitorSvc>*)p);
8924  }
8925  static void destruct_SmartIFlEIMonitorSvcgR(void *p) {
8926  typedef ::SmartIF<IMonitorSvc> current_t;
8927  ((current_t*)p)->~current_t();
8928  }
8929 } // end of namespace ROOT for class ::SmartIF<IMonitorSvc>
8930 
8931 namespace ROOT {
8932  // Wrappers around operator new
8933  static void *new_SmartIFlEIAuditorSvcgR(void *p) {
8934  return p ? new(p) ::SmartIF<IAuditorSvc> : new ::SmartIF<IAuditorSvc>;
8935  }
8936  static void *newArray_SmartIFlEIAuditorSvcgR(Long_t nElements, void *p) {
8937  return p ? new(p) ::SmartIF<IAuditorSvc>[nElements] : new ::SmartIF<IAuditorSvc>[nElements];
8938  }
8939  // Wrapper around operator delete
8940  static void delete_SmartIFlEIAuditorSvcgR(void *p) {
8941  delete ((::SmartIF<IAuditorSvc>*)p);
8942  }
8943  static void deleteArray_SmartIFlEIAuditorSvcgR(void *p) {
8944  delete [] ((::SmartIF<IAuditorSvc>*)p);
8945  }
8946  static void destruct_SmartIFlEIAuditorSvcgR(void *p) {
8947  typedef ::SmartIF<IAuditorSvc> current_t;
8948  ((current_t*)p)->~current_t();
8949  }
8950 } // end of namespace ROOT for class ::SmartIF<IAuditorSvc>
8951 
8952 namespace ROOT {
8953  // Wrappers around operator new
8954  static void *new_SmartIFlEIAlgContextSvcgR(void *p) {
8955  return p ? new(p) ::SmartIF<IAlgContextSvc> : new ::SmartIF<IAlgContextSvc>;
8956  }
8957  static void *newArray_SmartIFlEIAlgContextSvcgR(Long_t nElements, void *p) {
8958  return p ? new(p) ::SmartIF<IAlgContextSvc>[nElements] : new ::SmartIF<IAlgContextSvc>[nElements];
8959  }
8960  // Wrapper around operator delete
8961  static void delete_SmartIFlEIAlgContextSvcgR(void *p) {
8962  delete ((::SmartIF<IAlgContextSvc>*)p);
8963  }
8964  static void deleteArray_SmartIFlEIAlgContextSvcgR(void *p) {
8965  delete [] ((::SmartIF<IAlgContextSvc>*)p);
8966  }
8967  static void destruct_SmartIFlEIAlgContextSvcgR(void *p) {
8968  typedef ::SmartIF<IAlgContextSvc> current_t;
8969  ((current_t*)p)->~current_t();
8970  }
8971 } // end of namespace ROOT for class ::SmartIF<IAlgContextSvc>
8972 
8973 namespace ROOT {
8974  // Wrappers around operator new
8975  static void *new_SmartIFlEIAlgorithmgR(void *p) {
8976  return p ? new(p) ::SmartIF<IAlgorithm> : new ::SmartIF<IAlgorithm>;
8977  }
8978  static void *newArray_SmartIFlEIAlgorithmgR(Long_t nElements, void *p) {
8979  return p ? new(p) ::SmartIF<IAlgorithm>[nElements] : new ::SmartIF<IAlgorithm>[nElements];
8980  }
8981  // Wrapper around operator delete
8982  static void delete_SmartIFlEIAlgorithmgR(void *p) {
8983  delete ((::SmartIF<IAlgorithm>*)p);
8984  }
8985  static void deleteArray_SmartIFlEIAlgorithmgR(void *p) {
8986  delete [] ((::SmartIF<IAlgorithm>*)p);
8987  }
8988  static void destruct_SmartIFlEIAlgorithmgR(void *p) {
8989  typedef ::SmartIF<IAlgorithm> current_t;
8990  ((current_t*)p)->~current_t();
8991  }
8992 } // end of namespace ROOT for class ::SmartIF<IAlgorithm>
8993 
8994 namespace ROOT {
8995  // Wrappers around operator new
8996  static void *new_SmartIFlEIConversionSvcgR(void *p) {
8997  return p ? new(p) ::SmartIF<IConversionSvc> : new ::SmartIF<IConversionSvc>;
8998  }
8999  static void *newArray_SmartIFlEIConversionSvcgR(Long_t nElements, void *p) {
9000  return p ? new(p) ::SmartIF<IConversionSvc>[nElements] : new ::SmartIF<IConversionSvc>[nElements];
9001  }
9002  // Wrapper around operator delete
9003  static void delete_SmartIFlEIConversionSvcgR(void *p) {
9004  delete ((::SmartIF<IConversionSvc>*)p);
9005  }
9006  static void deleteArray_SmartIFlEIConversionSvcgR(void *p) {
9007  delete [] ((::SmartIF<IConversionSvc>*)p);
9008  }
9009  static void destruct_SmartIFlEIConversionSvcgR(void *p) {
9010  typedef ::SmartIF<IConversionSvc> current_t;
9011  ((current_t*)p)->~current_t();
9012  }
9013 } // end of namespace ROOT for class ::SmartIF<IConversionSvc>
9014 
9015 namespace ROOT {
9016  // Wrappers around operator new
9017  static void *new_SmartIFlEIRndmGengR(void *p) {
9018  return p ? new(p) ::SmartIF<IRndmGen> : new ::SmartIF<IRndmGen>;
9019  }
9020  static void *newArray_SmartIFlEIRndmGengR(Long_t nElements, void *p) {
9021  return p ? new(p) ::SmartIF<IRndmGen>[nElements] : new ::SmartIF<IRndmGen>[nElements];
9022  }
9023  // Wrapper around operator delete
9024  static void delete_SmartIFlEIRndmGengR(void *p) {
9025  delete ((::SmartIF<IRndmGen>*)p);
9026  }
9027  static void deleteArray_SmartIFlEIRndmGengR(void *p) {
9028  delete [] ((::SmartIF<IRndmGen>*)p);
9029  }
9030  static void destruct_SmartIFlEIRndmGengR(void *p) {
9031  typedef ::SmartIF<IRndmGen> current_t;
9032  ((current_t*)p)->~current_t();
9033  }
9034 } // end of namespace ROOT for class ::SmartIF<IRndmGen>
9035 
9036 namespace ROOT {
9037  // Wrappers around operator new
9038  static void *new_SmartIFlEIChronoStatSvcgR(void *p) {
9039  return p ? new(p) ::SmartIF<IChronoStatSvc> : new ::SmartIF<IChronoStatSvc>;
9040  }
9041  static void *newArray_SmartIFlEIChronoStatSvcgR(Long_t nElements, void *p) {
9042  return p ? new(p) ::SmartIF<IChronoStatSvc>[nElements] : new ::SmartIF<IChronoStatSvc>[nElements];
9043  }
9044  // Wrapper around operator delete
9045  static void delete_SmartIFlEIChronoStatSvcgR(void *p) {
9046  delete ((::SmartIF<IChronoStatSvc>*)p);
9047  }
9048  static void deleteArray_SmartIFlEIChronoStatSvcgR(void *p) {
9049  delete [] ((::SmartIF<IChronoStatSvc>*)p);
9050  }
9051  static void destruct_SmartIFlEIChronoStatSvcgR(void *p) {
9052  typedef ::SmartIF<IChronoStatSvc> current_t;
9053  ((current_t*)p)->~current_t();
9054  }
9055 } // end of namespace ROOT for class ::SmartIF<IChronoStatSvc>
9056 
9057 namespace ROOT {
9058  // Wrappers around operator new
9059  static void *new_SmartIFlEIHistogramSvcgR(void *p) {
9060  return p ? new(p) ::SmartIF<IHistogramSvc> : new ::SmartIF<IHistogramSvc>;
9061  }
9062  static void *newArray_SmartIFlEIHistogramSvcgR(Long_t nElements, void *p) {
9063  return p ? new(p) ::SmartIF<IHistogramSvc>[nElements] : new ::SmartIF<IHistogramSvc>[nElements];
9064  }
9065  // Wrapper around operator delete
9066  static void delete_SmartIFlEIHistogramSvcgR(void *p) {
9067  delete ((::SmartIF<IHistogramSvc>*)p);
9068  }
9069  static void deleteArray_SmartIFlEIHistogramSvcgR(void *p) {
9070  delete [] ((::SmartIF<IHistogramSvc>*)p);
9071  }
9072  static void destruct_SmartIFlEIHistogramSvcgR(void *p) {
9073  typedef ::SmartIF<IHistogramSvc> current_t;
9074  ((current_t*)p)->~current_t();
9075  }
9076 } // end of namespace ROOT for class ::SmartIF<IHistogramSvc>
9077 
9078 namespace ROOT {
9079  // Wrappers around operator new
9080  static void *new_SmartIFlEINTupleSvcgR(void *p) {
9081  return p ? new(p) ::SmartIF<INTupleSvc> : new ::SmartIF<INTupleSvc>;
9082  }
9083  static void *newArray_SmartIFlEINTupleSvcgR(Long_t nElements, void *p) {
9084  return p ? new(p) ::SmartIF<INTupleSvc>[nElements] : new ::SmartIF<INTupleSvc>[nElements];
9085  }
9086  // Wrapper around operator delete
9087  static void delete_SmartIFlEINTupleSvcgR(void *p) {
9088  delete ((::SmartIF<INTupleSvc>*)p);
9089  }
9090  static void deleteArray_SmartIFlEINTupleSvcgR(void *p) {
9091  delete [] ((::SmartIF<INTupleSvc>*)p);
9092  }
9093  static void destruct_SmartIFlEINTupleSvcgR(void *p) {
9094  typedef ::SmartIF<INTupleSvc> current_t;
9095  ((current_t*)p)->~current_t();
9096  }
9097 } // end of namespace ROOT for class ::SmartIF<INTupleSvc>
9098 
9099 namespace ROOT {
9100  // Wrappers around operator new
9101  static void *new_SmartIFlEIRndmGenSvcgR(void *p) {
9102  return p ? new(p) ::SmartIF<IRndmGenSvc> : new ::SmartIF<IRndmGenSvc>;
9103  }
9104  static void *newArray_SmartIFlEIRndmGenSvcgR(Long_t nElements, void *p) {
9105  return p ? new(p) ::SmartIF<IRndmGenSvc>[nElements] : new ::SmartIF<IRndmGenSvc>[nElements];
9106  }
9107  // Wrapper around operator delete
9108  static void delete_SmartIFlEIRndmGenSvcgR(void *p) {
9109  delete ((::SmartIF<IRndmGenSvc>*)p);
9110  }
9111  static void deleteArray_SmartIFlEIRndmGenSvcgR(void *p) {
9112  delete [] ((::SmartIF<IRndmGenSvc>*)p);
9113  }
9114  static void destruct_SmartIFlEIRndmGenSvcgR(void *p) {
9115  typedef ::SmartIF<IRndmGenSvc> current_t;
9116  ((current_t*)p)->~current_t();
9117  }
9118 } // end of namespace ROOT for class ::SmartIF<IRndmGenSvc>
9119 
9120 namespace ROOT {
9121  // Wrappers around operator new
9122  static void *new_SmartIFlEIExceptionSvcgR(void *p) {
9123  return p ? new(p) ::SmartIF<IExceptionSvc> : new ::SmartIF<IExceptionSvc>;
9124  }
9125  static void *newArray_SmartIFlEIExceptionSvcgR(Long_t nElements, void *p) {
9126  return p ? new(p) ::SmartIF<IExceptionSvc>[nElements] : new ::SmartIF<IExceptionSvc>[nElements];
9127  }
9128  // Wrapper around operator delete
9129  static void delete_SmartIFlEIExceptionSvcgR(void *p) {
9130  delete ((::SmartIF<IExceptionSvc>*)p);
9131  }
9132  static void deleteArray_SmartIFlEIExceptionSvcgR(void *p) {
9133  delete [] ((::SmartIF<IExceptionSvc>*)p);
9134  }
9135  static void destruct_SmartIFlEIExceptionSvcgR(void *p) {
9136  typedef ::SmartIF<IExceptionSvc> current_t;
9137  ((current_t*)p)->~current_t();
9138  }
9139 } // end of namespace ROOT for class ::SmartIF<IExceptionSvc>
9140 
9141 namespace ROOT {
9142  // Wrappers around operator new
9143  static void *new_SmartIFlEITimelineSvcgR(void *p) {
9144  return p ? new(p) ::SmartIF<ITimelineSvc> : new ::SmartIF<ITimelineSvc>;
9145  }
9146  static void *newArray_SmartIFlEITimelineSvcgR(Long_t nElements, void *p) {
9147  return p ? new(p) ::SmartIF<ITimelineSvc>[nElements] : new ::SmartIF<ITimelineSvc>[nElements];
9148  }
9149  // Wrapper around operator delete
9150  static void delete_SmartIFlEITimelineSvcgR(void *p) {
9151  delete ((::SmartIF<ITimelineSvc>*)p);
9152  }
9153  static void deleteArray_SmartIFlEITimelineSvcgR(void *p) {
9154  delete [] ((::SmartIF<ITimelineSvc>*)p);
9155  }
9156  static void destruct_SmartIFlEITimelineSvcgR(void *p) {
9157  typedef ::SmartIF<ITimelineSvc> current_t;
9158  ((current_t*)p)->~current_t();
9159  }
9160 } // end of namespace ROOT for class ::SmartIF<ITimelineSvc>
9161 
9162 namespace ROOT {
9163  // Wrappers around operator new
9164  static void *new_SmartIFlEIHiveWhiteBoardgR(void *p) {
9165  return p ? new(p) ::SmartIF<IHiveWhiteBoard> : new ::SmartIF<IHiveWhiteBoard>;
9166  }
9167  static void *newArray_SmartIFlEIHiveWhiteBoardgR(Long_t nElements, void *p) {
9168  return p ? new(p) ::SmartIF<IHiveWhiteBoard>[nElements] : new ::SmartIF<IHiveWhiteBoard>[nElements];
9169  }
9170  // Wrapper around operator delete
9171  static void delete_SmartIFlEIHiveWhiteBoardgR(void *p) {
9172  delete ((::SmartIF<IHiveWhiteBoard>*)p);
9173  }
9174  static void deleteArray_SmartIFlEIHiveWhiteBoardgR(void *p) {
9175  delete [] ((::SmartIF<IHiveWhiteBoard>*)p);
9176  }
9177  static void destruct_SmartIFlEIHiveWhiteBoardgR(void *p) {
9178  typedef ::SmartIF<IHiveWhiteBoard> current_t;
9179  ((current_t*)p)->~current_t();
9180  }
9181 } // end of namespace ROOT for class ::SmartIF<IHiveWhiteBoard>
9182 
9183 namespace ROOT {
9184  // Wrappers around operator new
9185  static void *new_SmartIFlEIAlgExecStateSvcgR(void *p) {
9186  return p ? new(p) ::SmartIF<IAlgExecStateSvc> : new ::SmartIF<IAlgExecStateSvc>;
9187  }
9188  static void *newArray_SmartIFlEIAlgExecStateSvcgR(Long_t nElements, void *p) {
9189  return p ? new(p) ::SmartIF<IAlgExecStateSvc>[nElements] : new ::SmartIF<IAlgExecStateSvc>[nElements];
9190  }
9191  // Wrapper around operator delete
9192  static void delete_SmartIFlEIAlgExecStateSvcgR(void *p) {
9193  delete ((::SmartIF<IAlgExecStateSvc>*)p);
9194  }
9195  static void deleteArray_SmartIFlEIAlgExecStateSvcgR(void *p) {
9196  delete [] ((::SmartIF<IAlgExecStateSvc>*)p);
9197  }
9198  static void destruct_SmartIFlEIAlgExecStateSvcgR(void *p) {
9199  typedef ::SmartIF<IAlgExecStateSvc> current_t;
9200  ((current_t*)p)->~current_t();
9201  }
9202 } // end of namespace ROOT for class ::SmartIF<IAlgExecStateSvc>
9203 
9204 namespace ROOT {
9205  // Wrappers around operator new
9206  static void *new_SmartIFlEISvcManagergR(void *p) {
9207  return p ? new(p) ::SmartIF<ISvcManager> : new ::SmartIF<ISvcManager>;
9208  }
9209  static void *newArray_SmartIFlEISvcManagergR(Long_t nElements, void *p) {
9210  return p ? new(p) ::SmartIF<ISvcManager>[nElements] : new ::SmartIF<ISvcManager>[nElements];
9211  }
9212  // Wrapper around operator delete
9213  static void delete_SmartIFlEISvcManagergR(void *p) {
9214  delete ((::SmartIF<ISvcManager>*)p);
9215  }
9216  static void deleteArray_SmartIFlEISvcManagergR(void *p) {
9217  delete [] ((::SmartIF<ISvcManager>*)p);
9218  }
9219  static void destruct_SmartIFlEISvcManagergR(void *p) {
9220  typedef ::SmartIF<ISvcManager> current_t;
9221  ((current_t*)p)->~current_t();
9222  }
9223 } // end of namespace ROOT for class ::SmartIF<ISvcManager>
9224 
9225 namespace ROOT {
9226  // Wrappers around operator new
9227  static void *new_SmartIFlEIIncidentSvcgR(void *p) {
9228  return p ? new(p) ::SmartIF<IIncidentSvc> : new ::SmartIF<IIncidentSvc>;
9229  }
9230  static void *newArray_SmartIFlEIIncidentSvcgR(Long_t nElements, void *p) {
9231  return p ? new(p) ::SmartIF<IIncidentSvc>[nElements] : new ::SmartIF<IIncidentSvc>[nElements];
9232  }
9233  // Wrapper around operator delete
9234  static void delete_SmartIFlEIIncidentSvcgR(void *p) {
9235  delete ((::SmartIF<IIncidentSvc>*)p);
9236  }
9237  static void deleteArray_SmartIFlEIIncidentSvcgR(void *p) {
9238  delete [] ((::SmartIF<IIncidentSvc>*)p);
9239  }
9240  static void destruct_SmartIFlEIIncidentSvcgR(void *p) {
9241  typedef ::SmartIF<IIncidentSvc> current_t;
9242  ((current_t*)p)->~current_t();
9243  }
9244 } // end of namespace ROOT for class ::SmartIF<IIncidentSvc>
9245 
9246 namespace ROOT {
9247  // Wrappers around operator new
9248  static void *new_SmartIFlEIEvtSelectorgR(void *p) {
9249  return p ? new(p) ::SmartIF<IEvtSelector> : new ::SmartIF<IEvtSelector>;
9250  }
9251  static void *newArray_SmartIFlEIEvtSelectorgR(Long_t nElements, void *p) {
9252  return p ? new(p) ::SmartIF<IEvtSelector>[nElements] : new ::SmartIF<IEvtSelector>[nElements];
9253  }
9254  // Wrapper around operator delete
9255  static void delete_SmartIFlEIEvtSelectorgR(void *p) {
9256  delete ((::SmartIF<IEvtSelector>*)p);
9257  }
9258  static void deleteArray_SmartIFlEIEvtSelectorgR(void *p) {
9259  delete [] ((::SmartIF<IEvtSelector>*)p);
9260  }
9261  static void destruct_SmartIFlEIEvtSelectorgR(void *p) {
9262  typedef ::SmartIF<IEvtSelector> current_t;
9263  ((current_t*)p)->~current_t();
9264  }
9265 } // end of namespace ROOT for class ::SmartIF<IEvtSelector>
9266 
9267 namespace ROOT {
9268  // Wrappers around operator new
9269  static void *new_SmartIFlEISelectStatementgR(void *p) {
9270  return p ? new(p) ::SmartIF<ISelectStatement> : new ::SmartIF<ISelectStatement>;
9271  }
9272  static void *newArray_SmartIFlEISelectStatementgR(Long_t nElements, void *p) {
9273  return p ? new(p) ::SmartIF<ISelectStatement>[nElements] : new ::SmartIF<ISelectStatement>[nElements];
9274  }
9275  // Wrapper around operator delete
9276  static void delete_SmartIFlEISelectStatementgR(void *p) {
9277  delete ((::SmartIF<ISelectStatement>*)p);
9278  }
9279  static void deleteArray_SmartIFlEISelectStatementgR(void *p) {
9280  delete [] ((::SmartIF<ISelectStatement>*)p);
9281  }
9282  static void destruct_SmartIFlEISelectStatementgR(void *p) {
9283  typedef ::SmartIF<ISelectStatement> current_t;
9284  ((current_t*)p)->~current_t();
9285  }
9286 } // end of namespace ROOT for class ::SmartIF<ISelectStatement>
9287 
9288 namespace ROOT {
9289  // Wrappers around operator new
9290  static void *new_SmartIFlEICounterSvcgR(void *p) {
9291  return p ? new(p) ::SmartIF<ICounterSvc> : new ::SmartIF<ICounterSvc>;
9292  }
9293  static void *newArray_SmartIFlEICounterSvcgR(Long_t nElements, void *p) {
9294  return p ? new(p) ::SmartIF<ICounterSvc>[nElements] : new ::SmartIF<ICounterSvc>[nElements];
9295  }
9296  // Wrapper around operator delete
9297  static void delete_SmartIFlEICounterSvcgR(void *p) {
9298  delete ((::SmartIF<ICounterSvc>*)p);
9299  }
9300  static void deleteArray_SmartIFlEICounterSvcgR(void *p) {
9301  delete [] ((::SmartIF<ICounterSvc>*)p);
9302  }
9303  static void destruct_SmartIFlEICounterSvcgR(void *p) {
9304  typedef ::SmartIF<ICounterSvc> current_t;
9305  ((current_t*)p)->~current_t();
9306  }
9307 } // end of namespace ROOT for class ::SmartIF<ICounterSvc>
9308 
9309 namespace ROOT {
9310  // Wrapper around operator delete
9311  static void delete_IProperty(void *p) {
9312  delete ((::IProperty*)p);
9313  }
9314  static void deleteArray_IProperty(void *p) {
9315  delete [] ((::IProperty*)p);
9316  }
9317  static void destruct_IProperty(void *p) {
9318  typedef ::IProperty current_t;
9319  ((current_t*)p)->~current_t();
9320  }
9321 } // end of namespace ROOT for class ::IProperty
9322 
9323 namespace ROOT {
9324  // Wrapper around operator delete
9325  static void delete_GaudicLcLDetailscLcLPropertyBase(void *p) {
9326  delete ((::Gaudi::Details::PropertyBase*)p);
9327  }
9328  static void deleteArray_GaudicLcLDetailscLcLPropertyBase(void *p) {
9329  delete [] ((::Gaudi::Details::PropertyBase*)p);
9330  }
9331  static void destruct_GaudicLcLDetailscLcLPropertyBase(void *p) {
9332  typedef ::Gaudi::Details::PropertyBase current_t;
9333  ((current_t*)p)->~current_t();
9334  }
9335 } // end of namespace ROOT for class ::Gaudi::Details::PropertyBase
9336 
9337 namespace ROOT {
9338  // Wrapper around operator delete
9339  static void delete_GaudiHandleProperty(void *p) {
9340  delete ((::GaudiHandleProperty*)p);
9341  }
9342  static void deleteArray_GaudiHandleProperty(void *p) {
9343  delete [] ((::GaudiHandleProperty*)p);
9344  }
9345  static void destruct_GaudiHandleProperty(void *p) {
9346  typedef ::GaudiHandleProperty current_t;
9347  ((current_t*)p)->~current_t();
9348  }
9349 } // end of namespace ROOT for class ::GaudiHandleProperty
9350 
9351 namespace ROOT {
9352  // Wrapper around operator delete
9353  static void delete_GaudiHandleArrayProperty(void *p) {
9354  delete ((::GaudiHandleArrayProperty*)p);
9355  }
9356  static void deleteArray_GaudiHandleArrayProperty(void *p) {
9357  delete [] ((::GaudiHandleArrayProperty*)p);
9358  }
9359  static void destruct_GaudiHandleArrayProperty(void *p) {
9360  typedef ::GaudiHandleArrayProperty current_t;
9361  ((current_t*)p)->~current_t();
9362  }
9363 } // end of namespace ROOT for class ::GaudiHandleArrayProperty
9364 
9365 namespace ROOT {
9366  // Wrapper around operator delete
9367  static void delete_ISvcManager(void *p) {
9368  delete ((::ISvcManager*)p);
9369  }
9370  static void deleteArray_ISvcManager(void *p) {
9371  delete [] ((::ISvcManager*)p);
9372  }
9373  static void destruct_ISvcManager(void *p) {
9374  typedef ::ISvcManager current_t;
9375  ((current_t*)p)->~current_t();
9376  }
9377 } // end of namespace ROOT for class ::ISvcManager
9378 
9379 namespace ROOT {
9380  // Wrapper around operator delete
9381  static void delete_ISvcLocator(void *p) {
9382  delete ((::ISvcLocator*)p);
9383  }
9384  static void deleteArray_ISvcLocator(void *p) {
9385  delete [] ((::ISvcLocator*)p);
9386  }
9387  static void destruct_ISvcLocator(void *p) {
9388  typedef ::ISvcLocator current_t;
9389  ((current_t*)p)->~current_t();
9390  }
9391 } // end of namespace ROOT for class ::ISvcLocator
9392 
9393 namespace ROOT {
9394  // Wrapper around operator delete
9395  static void delete_IAlgTool(void *p) {
9396  delete ((::IAlgTool*)p);
9397  }
9398  static void deleteArray_IAlgTool(void *p) {
9399  delete [] ((::IAlgTool*)p);
9400  }
9401  static void destruct_IAlgTool(void *p) {
9402  typedef ::IAlgTool current_t;
9403  ((current_t*)p)->~current_t();
9404  }
9405 } // end of namespace ROOT for class ::IAlgTool
9406 
9407 namespace ROOT {
9408  // Wrapper around operator delete
9409  static void delete_IAuditor(void *p) {
9410  delete ((::IAuditor*)p);
9411  }
9412  static void deleteArray_IAuditor(void *p) {
9413  delete [] ((::IAuditor*)p);
9414  }
9415  static void destruct_IAuditor(void *p) {
9416  typedef ::IAuditor current_t;
9417  ((current_t*)p)->~current_t();
9418  }
9419 } // end of namespace ROOT for class ::IAuditor
9420 
9421 namespace ROOT {
9422  // Wrapper around operator delete
9423  static void delete_IAuditorSvc(void *p) {
9424  delete ((::IAuditorSvc*)p);
9425  }
9426  static void deleteArray_IAuditorSvc(void *p) {
9427  delete [] ((::IAuditorSvc*)p);
9428  }
9429  static void destruct_IAuditorSvc(void *p) {
9430  typedef ::IAuditorSvc current_t;
9431  ((current_t*)p)->~current_t();
9432  }
9433 } // end of namespace ROOT for class ::IAuditorSvc
9434 
9435 namespace ROOT {
9436  // Wrapper around operator delete
9437  static void delete_IDataProviderSvc(void *p) {
9438  delete ((::IDataProviderSvc*)p);
9439  }
9440  static void deleteArray_IDataProviderSvc(void *p) {
9441  delete [] ((::IDataProviderSvc*)p);
9442  }
9443  static void destruct_IDataProviderSvc(void *p) {
9444  typedef ::IDataProviderSvc current_t;
9445  ((current_t*)p)->~current_t();
9446  }
9447 } // end of namespace ROOT for class ::IDataProviderSvc
9448 
9449 namespace ROOT {
9450  // Wrapper around operator delete
9451  static void delete_IMonitorSvc(void *p) {
9452  delete ((::IMonitorSvc*)p);
9453  }
9454  static void deleteArray_IMonitorSvc(void *p) {
9455  delete [] ((::IMonitorSvc*)p);
9456  }
9457  static void destruct_IMonitorSvc(void *p) {
9458  typedef ::IMonitorSvc current_t;
9459  ((current_t*)p)->~current_t();
9460  }
9461 } // end of namespace ROOT for class ::IMonitorSvc
9462 
9463 namespace ROOT {
9464  // Wrapper around operator delete
9465  static void delete_IToolSvc(void *p) {
9466  delete ((::IToolSvc*)p);
9467  }
9468  static void deleteArray_IToolSvc(void *p) {
9469  delete [] ((::IToolSvc*)p);
9470  }
9471  static void destruct_IToolSvc(void *p) {
9472  typedef ::IToolSvc current_t;
9473  ((current_t*)p)->~current_t();
9474  }
9475 } // end of namespace ROOT for class ::IToolSvc
9476 
9477 namespace ROOT {
9478  // Wrapper around operator delete
9479  static void delete_DataObjectHandleProperty(void *p) {
9480  delete ((::DataObjectHandleProperty*)p);
9481  }
9482  static void deleteArray_DataObjectHandleProperty(void *p) {
9483  delete [] ((::DataObjectHandleProperty*)p);
9484  }
9485  static void destruct_DataObjectHandleProperty(void *p) {
9486  typedef ::DataObjectHandleProperty current_t;
9487  ((current_t*)p)->~current_t();
9488  }
9489 } // end of namespace ROOT for class ::DataObjectHandleProperty
9490 
9491 namespace ROOT {
9492  // Wrapper around operator delete
9493  static void delete_GaudiHandleInfo(void *p) {
9494  delete ((::GaudiHandleInfo*)p);
9495  }
9496  static void deleteArray_GaudiHandleInfo(void *p) {
9497  delete [] ((::GaudiHandleInfo*)p);
9498  }
9499  static void destruct_GaudiHandleInfo(void *p) {
9500  typedef ::GaudiHandleInfo current_t;
9501  ((current_t*)p)->~current_t();
9502  }
9503 } // end of namespace ROOT for class ::GaudiHandleInfo
9504 
9505 namespace ROOT {
9506  // Wrapper around operator delete
9507  static void delete_GaudiHandleBase(void *p) {
9508  delete ((::GaudiHandleBase*)p);
9509  }
9510  static void deleteArray_GaudiHandleBase(void *p) {
9511  delete [] ((::GaudiHandleBase*)p);
9512  }
9513  static void destruct_GaudiHandleBase(void *p) {
9514  typedef ::GaudiHandleBase current_t;
9515  ((current_t*)p)->~current_t();
9516  }
9517 } // end of namespace ROOT for class ::GaudiHandleBase
9518 
9519 namespace ROOT {
9520  // Wrapper around operator delete
9521  static void delete_GaudiHandleArrayBase(void *p) {
9522  delete ((::GaudiHandleArrayBase*)p);
9523  }
9524  static void deleteArray_GaudiHandleArrayBase(void *p) {
9525  delete [] ((::GaudiHandleArrayBase*)p);
9526  }
9527  static void destruct_GaudiHandleArrayBase(void *p) {
9528  typedef ::GaudiHandleArrayBase current_t;
9529  ((current_t*)p)->~current_t();
9530  }
9531 } // end of namespace ROOT for class ::GaudiHandleArrayBase
9532 
9533 namespace ROOT {
9534  // Wrapper around operator delete
9535  static void delete_AlgTool(void *p) {
9536  delete ((::AlgTool*)p);
9537  }
9538  static void deleteArray_AlgTool(void *p) {
9539  delete [] ((::AlgTool*)p);
9540  }
9541  static void destruct_AlgTool(void *p) {
9542  typedef ::AlgTool current_t;
9543  ((current_t*)p)->~current_t();
9544  }
9545 } // end of namespace ROOT for class ::AlgTool
9546 
9547 namespace ROOT {
9548  // Wrapper around operator delete
9549  static void delete_IAlgorithm(void *p) {
9550  delete ((::IAlgorithm*)p);
9551  }
9552  static void deleteArray_IAlgorithm(void *p) {
9553  delete [] ((::IAlgorithm*)p);
9554  }
9555  static void destruct_IAlgorithm(void *p) {
9556  typedef ::IAlgorithm current_t;
9557  ((current_t*)p)->~current_t();
9558  }
9559 } // end of namespace ROOT for class ::IAlgorithm
9560 
9561 namespace ROOT {
9562  // Wrapper around operator delete
9563  static void delete_IAlgContextSvc(void *p) {
9564  delete ((::IAlgContextSvc*)p);
9565  }
9566  static void deleteArray_IAlgContextSvc(void *p) {
9567  delete [] ((::IAlgContextSvc*)p);
9568  }
9569  static void destruct_IAlgContextSvc(void *p) {
9570  typedef ::IAlgContextSvc current_t;
9571  ((current_t*)p)->~current_t();
9572  }
9573 } // end of namespace ROOT for class ::IAlgContextSvc
9574 
9575 namespace ROOT {
9576  // Wrapper around operator delete
9577  static void delete_IChronoSvc(void *p) {
9578  delete ((::IChronoSvc*)p);
9579  }
9580  static void deleteArray_IChronoSvc(void *p) {
9581  delete [] ((::IChronoSvc*)p);
9582  }
9583  static void destruct_IChronoSvc(void *p) {
9584  typedef ::IChronoSvc current_t;
9585  ((current_t*)p)->~current_t();
9586  }
9587 } // end of namespace ROOT for class ::IChronoSvc
9588 
9589 namespace ROOT {
9590  // Wrapper around operator delete
9591  static void delete_IStatSvc(void *p) {
9592  delete ((::IStatSvc*)p);
9593  }
9594  static void deleteArray_IStatSvc(void *p) {
9595  delete [] ((::IStatSvc*)p);
9596  }
9597  static void destruct_IStatSvc(void *p) {
9598  typedef ::IStatSvc current_t;
9599  ((current_t*)p)->~current_t();
9600  }
9601 } // end of namespace ROOT for class ::IStatSvc
9602 
9603 namespace ROOT {
9604  // Wrapper around operator delete
9605  static void delete_IChronoStatSvc(void *p) {
9606  delete ((::IChronoStatSvc*)p);
9607  }
9608  static void deleteArray_IChronoStatSvc(void *p) {
9609  delete [] ((::IChronoStatSvc*)p);
9610  }
9611  static void destruct_IChronoStatSvc(void *p) {
9612  typedef ::IChronoStatSvc current_t;
9613  ((current_t*)p)->~current_t();
9614  }
9615 } // end of namespace ROOT for class ::IChronoStatSvc
9616 
9617 namespace ROOT {
9618  // Wrapper around operator delete
9619  static void delete_IConverter(void *p) {
9620  delete ((::IConverter*)p);
9621  }
9622  static void deleteArray_IConverter(void *p) {
9623  delete [] ((::IConverter*)p);
9624  }
9625  static void destruct_IConverter(void *p) {
9626  typedef ::IConverter current_t;
9627  ((current_t*)p)->~current_t();
9628  }
9629 } // end of namespace ROOT for class ::IConverter
9630 
9631 namespace ROOT {
9632  // Wrapper around operator delete
9633  static void delete_IConversionSvc(void *p) {
9634  delete ((::IConversionSvc*)p);
9635  }
9636  static void deleteArray_IConversionSvc(void *p) {
9637  delete [] ((::IConversionSvc*)p);
9638  }
9639  static void destruct_IConversionSvc(void *p) {
9640  typedef ::IConversionSvc current_t;
9641  ((current_t*)p)->~current_t();
9642  }
9643 } // end of namespace ROOT for class ::IConversionSvc
9644 
9645 namespace ROOT {
9646  // Wrapper around operator delete
9647  static void delete_IExceptionSvc(void *p) {
9648  delete ((::IExceptionSvc*)p);
9649  }
9650  static void deleteArray_IExceptionSvc(void *p) {
9651  delete [] ((::IExceptionSvc*)p);
9652  }
9653  static void destruct_IExceptionSvc(void *p) {
9654  typedef ::IExceptionSvc current_t;
9655  ((current_t*)p)->~current_t();
9656  }
9657 } // end of namespace ROOT for class ::IExceptionSvc
9658 
9659 namespace ROOT {
9660  // Wrapper around operator delete
9661  static void delete_IHistogramSvc(void *p) {
9662  delete ((::IHistogramSvc*)p);
9663  }
9664  static void deleteArray_IHistogramSvc(void *p) {
9665  delete [] ((::IHistogramSvc*)p);
9666  }
9667  static void destruct_IHistogramSvc(void *p) {
9668  typedef ::IHistogramSvc current_t;
9669  ((current_t*)p)->~current_t();
9670  }
9671 } // end of namespace ROOT for class ::IHistogramSvc
9672 
9673 namespace ROOT {
9674  // Wrapper around operator delete
9675  static void delete_INTupleSvc(void *p) {
9676  delete ((::INTupleSvc*)p);
9677  }
9678  static void deleteArray_INTupleSvc(void *p) {
9679  delete [] ((::INTupleSvc*)p);
9680  }
9681  static void destruct_INTupleSvc(void *p) {
9682  typedef ::INTupleSvc current_t;
9683  ((current_t*)p)->~current_t();
9684  }
9685 } // end of namespace ROOT for class ::INTupleSvc
9686 
9687 namespace ROOT {
9688  // Wrapper around operator delete
9689  static void delete_IRndmGen(void *p) {
9690  delete ((::IRndmGen*)p);
9691  }
9692  static void deleteArray_IRndmGen(void *p) {
9693  delete [] ((::IRndmGen*)p);
9694  }
9695  static void destruct_IRndmGen(void *p) {
9696  typedef ::IRndmGen current_t;
9697  ((current_t*)p)->~current_t();
9698  }
9699 } // end of namespace ROOT for class ::IRndmGen
9700 
9701 namespace ROOT {
9702  // Wrapper around operator delete
9703  static void delete_IRndmGencLcLParam(void *p) {
9704  delete ((::IRndmGen::Param*)p);
9705  }
9706  static void deleteArray_IRndmGencLcLParam(void *p) {
9707  delete [] ((::IRndmGen::Param*)p);
9708  }
9709  static void destruct_IRndmGencLcLParam(void *p) {
9710  typedef ::IRndmGen::Param current_t;
9711  ((current_t*)p)->~current_t();
9712  }
9713 } // end of namespace ROOT for class ::IRndmGen::Param
9714 
9715 namespace ROOT {
9716  // Wrapper around operator delete
9717  static void delete_IRndmGenSvc(void *p) {
9718  delete ((::IRndmGenSvc*)p);
9719  }
9720  static void deleteArray_IRndmGenSvc(void *p) {
9721  delete [] ((::IRndmGenSvc*)p);
9722  }
9723  static void destruct_IRndmGenSvc(void *p) {
9724  typedef ::IRndmGenSvc current_t;
9725  ((current_t*)p)->~current_t();
9726  }
9727 } // end of namespace ROOT for class ::IRndmGenSvc
9728 
9729 namespace ROOT {
9730  // Wrapper around operator delete
9731  static void delete_Algorithm(void *p) {
9732  delete ((::Algorithm*)p);
9733  }
9734  static void deleteArray_Algorithm(void *p) {
9735  delete [] ((::Algorithm*)p);
9736  }
9737  static void destruct_Algorithm(void *p) {
9738  typedef ::Algorithm current_t;
9739  ((current_t*)p)->~current_t();
9740  }
9741 } // end of namespace ROOT for class ::Algorithm
9742 
9743 namespace ROOT {
9744  // Wrappers around operator new
9745  static void *new_DataObject(void *p) {
9746  return p ? new(p) ::DataObject : new ::DataObject;
9747  }
9748  static void *newArray_DataObject(Long_t nElements, void *p) {
9749  return p ? new(p) ::DataObject[nElements] : new ::DataObject[nElements];
9750  }
9751  // Wrapper around operator delete
9752  static void delete_DataObject(void *p) {
9753  delete ((::DataObject*)p);
9754  }
9755  static void deleteArray_DataObject(void *p) {
9756  delete [] ((::DataObject*)p);
9757  }
9758  static void destruct_DataObject(void *p) {
9759  typedef ::DataObject current_t;
9760  ((current_t*)p)->~current_t();
9761  }
9762 } // end of namespace ROOT for class ::DataObject
9763 
9764 namespace ROOT {
9765  // Wrapper around operator delete
9766  static void delete_ObjectContainerBase(void *p) {
9767  delete ((::ObjectContainerBase*)p);
9768  }
9769  static void deleteArray_ObjectContainerBase(void *p) {
9770  delete [] ((::ObjectContainerBase*)p);
9771  }
9772  static void destruct_ObjectContainerBase(void *p) {
9773  typedef ::ObjectContainerBase current_t;
9774  ((current_t*)p)->~current_t();
9775  }
9776 } // end of namespace ROOT for class ::ObjectContainerBase
9777 
9778 namespace ROOT {
9779 } // end of namespace ROOT for class ::ContainedObject
9780 
9781 namespace ROOT {
9782  // Wrapper around operator delete
9783  static void delete_IDataStreamTool(void *p) {
9784  delete ((::IDataStreamTool*)p);
9785  }
9786  static void deleteArray_IDataStreamTool(void *p) {
9787  delete [] ((::IDataStreamTool*)p);
9788  }
9789  static void destruct_IDataStreamTool(void *p) {
9790  typedef ::IDataStreamTool current_t;
9791  ((current_t*)p)->~current_t();
9792  }
9793 } // end of namespace ROOT for class ::IDataStreamTool
9794 
9795 namespace ROOT {
9796  // Wrapper around operator delete
9797  static void delete_IOpaqueAddress(void *p) {
9798  delete ((::IOpaqueAddress*)p);
9799  }
9800  static void deleteArray_IOpaqueAddress(void *p) {
9801  delete [] ((::IOpaqueAddress*)p);
9802  }
9803  static void destruct_IOpaqueAddress(void *p) {
9804  typedef ::IOpaqueAddress current_t;
9805  ((current_t*)p)->~current_t();
9806  }
9807 } // end of namespace ROOT for class ::IOpaqueAddress
9808 
9809 namespace ROOT {
9810  // Wrapper around operator delete
9811  static void delete_IEvtSelector(void *p) {
9812  delete ((::IEvtSelector*)p);
9813  }
9814  static void deleteArray_IEvtSelector(void *p) {
9815  delete [] ((::IEvtSelector*)p);
9816  }
9817  static void destruct_IEvtSelector(void *p) {
9818  typedef ::IEvtSelector current_t;
9819  ((current_t*)p)->~current_t();
9820  }
9821 } // end of namespace ROOT for class ::IEvtSelector
9822 
9823 namespace ROOT {
9824  // Wrapper around operator delete
9825  static void delete_Incident(void *p) {
9826  delete ((::Incident*)p);
9827  }
9828  static void deleteArray_Incident(void *p) {
9829  delete [] ((::Incident*)p);
9830  }
9831  static void destruct_Incident(void *p) {
9832  typedef ::Incident current_t;
9833  ((current_t*)p)->~current_t();
9834  }
9835 } // end of namespace ROOT for class ::Incident
9836 
9837 namespace ROOT {
9838  // Wrapper around operator delete
9839  static void delete_IIncidentSvc(void *p) {
9840  delete ((::IIncidentSvc*)p);
9841  }
9842  static void deleteArray_IIncidentSvc(void *p) {
9843  delete [] ((::IIncidentSvc*)p);
9844  }
9845  static void destruct_IIncidentSvc(void *p) {
9846  typedef ::IIncidentSvc current_t;
9847  ((current_t*)p)->~current_t();
9848  }
9849 } // end of namespace ROOT for class ::IIncidentSvc
9850 
9851 namespace ROOT {
9852 } // end of namespace ROOT for class ::Service
9853 
9854 namespace ROOT {
9855  // Wrappers around operator new
9856  static void *new_GenericAddress(void *p) {
9857  return p ? new(p) ::GenericAddress : new ::GenericAddress;
9858  }
9859  static void *newArray_GenericAddress(Long_t nElements, void *p) {
9860  return p ? new(p) ::GenericAddress[nElements] : new ::GenericAddress[nElements];
9861  }
9862  // Wrapper around operator delete
9863  static void delete_GenericAddress(void *p) {
9864  delete ((::GenericAddress*)p);
9865  }
9866  static void deleteArray_GenericAddress(void *p) {
9867  delete [] ((::GenericAddress*)p);
9868  }
9869  static void destruct_GenericAddress(void *p) {
9870  typedef ::GenericAddress current_t;
9871  ((current_t*)p)->~current_t();
9872  }
9873 } // end of namespace ROOT for class ::GenericAddress
9874 
9875 namespace ROOT {
9876  // Wrappers around operator new
9877  static void *new_KeyedObjectlEintgR(void *p) {
9878  return p ? new(p) ::KeyedObject<int> : new ::KeyedObject<int>;
9879  }
9880  static void *newArray_KeyedObjectlEintgR(Long_t nElements, void *p) {
9881  return p ? new(p) ::KeyedObject<int>[nElements] : new ::KeyedObject<int>[nElements];
9882  }
9883  // Wrapper around operator delete
9884  static void delete_KeyedObjectlEintgR(void *p) {
9885  delete ((::KeyedObject<int>*)p);
9886  }
9887  static void deleteArray_KeyedObjectlEintgR(void *p) {
9888  delete [] ((::KeyedObject<int>*)p);
9889  }
9890  static void destruct_KeyedObjectlEintgR(void *p) {
9891  typedef ::KeyedObject<int> current_t;
9892  ((current_t*)p)->~current_t();
9893  }
9894 } // end of namespace ROOT for class ::KeyedObject<int>
9895 
9896 namespace ROOT {
9897  // Wrappers around operator new
9898  static void *new_KeyedObjectlEunsignedsPintgR(void *p) {
9899  return p ? new(p) ::KeyedObject<unsigned int> : new ::KeyedObject<unsigned int>;
9900  }
9901  static void *newArray_KeyedObjectlEunsignedsPintgR(Long_t nElements, void *p) {
9902  return p ? new(p) ::KeyedObject<unsigned int>[nElements] : new ::KeyedObject<unsigned int>[nElements];
9903  }
9904  // Wrapper around operator delete
9905  static void delete_KeyedObjectlEunsignedsPintgR(void *p) {
9906  delete ((::KeyedObject<unsigned int>*)p);
9907  }
9908  static void deleteArray_KeyedObjectlEunsignedsPintgR(void *p) {
9909  delete [] ((::KeyedObject<unsigned int>*)p);
9910  }
9911  static void destruct_KeyedObjectlEunsignedsPintgR(void *p) {
9912  typedef ::KeyedObject<unsigned int> current_t;
9913  ((current_t*)p)->~current_t();
9914  }
9915 } // end of namespace ROOT for class ::KeyedObject<unsigned int>
9916 
9917 namespace ROOT {
9918  // Wrappers around operator new
9919  static void *new_KeyedObjectlElonggR(void *p) {
9920  return p ? new(p) ::KeyedObject<long> : new ::KeyedObject<long>;
9921  }
9922  static void *newArray_KeyedObjectlElonggR(Long_t nElements, void *p) {
9923  return p ? new(p) ::KeyedObject<long>[nElements] : new ::KeyedObject<long>[nElements];
9924  }
9925  // Wrapper around operator delete
9926  static void delete_KeyedObjectlElonggR(void *p) {
9927  delete ((::KeyedObject<long>*)p);
9928  }
9929  static void deleteArray_KeyedObjectlElonggR(void *p) {
9930  delete [] ((::KeyedObject<long>*)p);
9931  }
9932  static void destruct_KeyedObjectlElonggR(void *p) {
9933  typedef ::KeyedObject<long> current_t;
9934  ((current_t*)p)->~current_t();
9935  }
9936 } // end of namespace ROOT for class ::KeyedObject<long>
9937 
9938 namespace ROOT {
9939  // Wrappers around operator new
9940  static void *new_KeyedObjectlEunsignedsPlonggR(void *p) {
9941  return p ? new(p) ::KeyedObject<unsigned long> : new ::KeyedObject<unsigned long>;
9942  }
9943  static void *newArray_KeyedObjectlEunsignedsPlonggR(Long_t nElements, void *p) {
9944  return p ? new(p) ::KeyedObject<unsigned long>[nElements] : new ::KeyedObject<unsigned long>[nElements];
9945  }
9946  // Wrapper around operator delete
9947  static void delete_KeyedObjectlEunsignedsPlonggR(void *p) {
9948  delete ((::KeyedObject<unsigned long>*)p);
9949  }
9950  static void deleteArray_KeyedObjectlEunsignedsPlonggR(void *p) {
9951  delete [] ((::KeyedObject<unsigned long>*)p);
9952  }
9953  static void destruct_KeyedObjectlEunsignedsPlonggR(void *p) {
9954  typedef ::KeyedObject<unsigned long> current_t;
9955  ((current_t*)p)->~current_t();
9956  }
9957 } // end of namespace ROOT for class ::KeyedObject<unsigned long>
9958 
9959 namespace ROOT {
9960  // Wrappers around operator new
9961  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p) {
9962  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::map> : new ::Containers::KeyedObjectManager<Containers::map>;
9963  }
9964  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(Long_t nElements, void *p) {
9965  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::map>[nElements] : new ::Containers::KeyedObjectManager<Containers::map>[nElements];
9966  }
9967  // Wrapper around operator delete
9968  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p) {
9969  delete ((::Containers::KeyedObjectManager<Containers::map>*)p);
9970  }
9971  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p) {
9972  delete [] ((::Containers::KeyedObjectManager<Containers::map>*)p);
9973  }
9974  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p) {
9975  typedef ::Containers::KeyedObjectManager<Containers::map> current_t;
9976  ((current_t*)p)->~current_t();
9977  }
9978 } // end of namespace ROOT for class ::Containers::KeyedObjectManager<Containers::map>
9979 
9980 namespace ROOT {
9981  // Wrappers around operator new
9982  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p) {
9983  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::hashmap> : new ::Containers::KeyedObjectManager<Containers::hashmap>;
9984  }
9985  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(Long_t nElements, void *p) {
9986  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::hashmap>[nElements] : new ::Containers::KeyedObjectManager<Containers::hashmap>[nElements];
9987  }
9988  // Wrapper around operator delete
9989  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p) {
9990  delete ((::Containers::KeyedObjectManager<Containers::hashmap>*)p);
9991  }
9992  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p) {
9993  delete [] ((::Containers::KeyedObjectManager<Containers::hashmap>*)p);
9994  }
9995  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p) {
9996  typedef ::Containers::KeyedObjectManager<Containers::hashmap> current_t;
9997  ((current_t*)p)->~current_t();
9998  }
9999 } // end of namespace ROOT for class ::Containers::KeyedObjectManager<Containers::hashmap>
10000 
10001 namespace ROOT {
10002  // Wrappers around operator new
10003  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p) {
10004  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::vector> : new ::Containers::KeyedObjectManager<Containers::vector>;
10005  }
10006  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(Long_t nElements, void *p) {
10007  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::vector>[nElements] : new ::Containers::KeyedObjectManager<Containers::vector>[nElements];
10008  }
10009  // Wrapper around operator delete
10010  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p) {
10011  delete ((::Containers::KeyedObjectManager<Containers::vector>*)p);
10012  }
10013  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p) {
10014  delete [] ((::Containers::KeyedObjectManager<Containers::vector>*)p);
10015  }
10016  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p) {
10017  typedef ::Containers::KeyedObjectManager<Containers::vector> current_t;
10018  ((current_t*)p)->~current_t();
10019  }
10020 } // end of namespace ROOT for class ::Containers::KeyedObjectManager<Containers::vector>
10021 
10022 namespace ROOT {
10023  // Wrappers around operator new
10024  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p) {
10025  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::array> : new ::Containers::KeyedObjectManager<Containers::array>;
10026  }
10027  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(Long_t nElements, void *p) {
10028  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::array>[nElements] : new ::Containers::KeyedObjectManager<Containers::array>[nElements];
10029  }
10030  // Wrapper around operator delete
10031  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p) {
10032  delete ((::Containers::KeyedObjectManager<Containers::array>*)p);
10033  }
10034  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p) {
10035  delete [] ((::Containers::KeyedObjectManager<Containers::array>*)p);
10036  }
10037  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p) {
10038  typedef ::Containers::KeyedObjectManager<Containers::array> current_t;
10039  ((current_t*)p)->~current_t();
10040  }
10041 } // end of namespace ROOT for class ::Containers::KeyedObjectManager<Containers::array>
10042 
10043 namespace ROOT {
10044  // Wrappers around operator new
10045  static void *new_LinkManager(void *p) {
10046  return p ? new(p) ::LinkManager : new ::LinkManager;
10047  }
10048  static void *newArray_LinkManager(Long_t nElements, void *p) {
10049  return p ? new(p) ::LinkManager[nElements] : new ::LinkManager[nElements];
10050  }
10051  // Wrapper around operator delete
10052  static void delete_LinkManager(void *p) {
10053  delete ((::LinkManager*)p);
10054  }
10055  static void deleteArray_LinkManager(void *p) {
10056  delete [] ((::LinkManager*)p);
10057  }
10058  static void destruct_LinkManager(void *p) {
10059  typedef ::LinkManager current_t;
10060  ((current_t*)p)->~current_t();
10061  }
10062 } // end of namespace ROOT for class ::LinkManager
10063 
10064 namespace ROOT {
10065  // Wrappers around operator new
10066  static void *new_LinkManagercLcLLink(void *p) {
10067  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::LinkManager::Link : new ::LinkManager::Link;
10068  }
10069  static void *newArray_LinkManagercLcLLink(Long_t nElements, void *p) {
10070  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::LinkManager::Link[nElements] : new ::LinkManager::Link[nElements];
10071  }
10072  // Wrapper around operator delete
10073  static void delete_LinkManagercLcLLink(void *p) {
10074  delete ((::LinkManager::Link*)p);
10075  }
10076  static void deleteArray_LinkManagercLcLLink(void *p) {
10077  delete [] ((::LinkManager::Link*)p);
10078  }
10079  static void destruct_LinkManagercLcLLink(void *p) {
10080  typedef ::LinkManager::Link current_t;
10081  ((current_t*)p)->~current_t();
10082  }
10083 } // end of namespace ROOT for class ::LinkManager::Link
10084 
10085 namespace ROOT {
10086  // Wrapper around operator delete
10087  static void delete_IJobOptionsSvc(void *p) {
10088  delete ((::IJobOptionsSvc*)p);
10089  }
10090  static void deleteArray_IJobOptionsSvc(void *p) {
10091  delete [] ((::IJobOptionsSvc*)p);
10092  }
10093  static void destruct_IJobOptionsSvc(void *p) {
10094  typedef ::IJobOptionsSvc current_t;
10095  ((current_t*)p)->~current_t();
10096  }
10097 } // end of namespace ROOT for class ::IJobOptionsSvc
10098 
10099 namespace ROOT {
10100  // Wrappers around operator new
10101  static void *new_MetaData(void *p) {
10102  return p ? new(p) ::MetaData : new ::MetaData;
10103  }
10104  static void *newArray_MetaData(Long_t nElements, void *p) {
10105  return p ? new(p) ::MetaData[nElements] : new ::MetaData[nElements];
10106  }
10107  // Wrapper around operator delete
10108  static void delete_MetaData(void *p) {
10109  delete ((::MetaData*)p);
10110  }
10111  static void deleteArray_MetaData(void *p) {
10112  delete [] ((::MetaData*)p);
10113  }
10114  static void destruct_MetaData(void *p) {
10115  typedef ::MetaData current_t;
10116  ((current_t*)p)->~current_t();
10117  }
10118 } // end of namespace ROOT for class ::MetaData
10119 
10120 namespace ROOT {
10121  // Wrappers around operator new
10122  static void *new_SmartRefBase(void *p) {
10123  return p ? new(p) ::SmartRefBase : new ::SmartRefBase;
10124  }
10125  static void *newArray_SmartRefBase(Long_t nElements, void *p) {
10126  return p ? new(p) ::SmartRefBase[nElements] : new ::SmartRefBase[nElements];
10127  }
10128  // Wrapper around operator delete
10129  static void delete_SmartRefBase(void *p) {
10130  delete ((::SmartRefBase*)p);
10131  }
10132  static void deleteArray_SmartRefBase(void *p) {
10133  delete [] ((::SmartRefBase*)p);
10134  }
10135  static void destruct_SmartRefBase(void *p) {
10136  typedef ::SmartRefBase current_t;
10137  ((current_t*)p)->~current_t();
10138  }
10139 } // end of namespace ROOT for class ::SmartRefBase
10140 
10141 namespace ROOT {
10142  // Wrappers around operator new
10143  static void *new_SmartReflEDataObjectgR(void *p) {
10144  return p ? new(p) ::SmartRef<DataObject> : new ::SmartRef<DataObject>;
10145  }
10146  static void *newArray_SmartReflEDataObjectgR(Long_t nElements, void *p) {
10147  return p ? new(p) ::SmartRef<DataObject>[nElements] : new ::SmartRef<DataObject>[nElements];
10148  }
10149  // Wrapper around operator delete
10150  static void delete_SmartReflEDataObjectgR(void *p) {
10151  delete ((::SmartRef<DataObject>*)p);
10152  }
10153  static void deleteArray_SmartReflEDataObjectgR(void *p) {
10154  delete [] ((::SmartRef<DataObject>*)p);
10155  }
10156  static void destruct_SmartReflEDataObjectgR(void *p) {
10157  typedef ::SmartRef<DataObject> current_t;
10158  ((current_t*)p)->~current_t();
10159  }
10160 } // end of namespace ROOT for class ::SmartRef<DataObject>
10161 
10162 namespace ROOT {
10163  // Wrappers around operator new
10164  static void *new_SmartReflEContainedObjectgR(void *p) {
10165  return p ? new(p) ::SmartRef<ContainedObject> : new ::SmartRef<ContainedObject>;
10166  }
10167  static void *newArray_SmartReflEContainedObjectgR(Long_t nElements, void *p) {
10168  return p ? new(p) ::SmartRef<ContainedObject>[nElements] : new ::SmartRef<ContainedObject>[nElements];
10169  }
10170  // Wrapper around operator delete
10171  static void delete_SmartReflEContainedObjectgR(void *p) {
10172  delete ((::SmartRef<ContainedObject>*)p);
10173  }
10174  static void deleteArray_SmartReflEContainedObjectgR(void *p) {
10175  delete [] ((::SmartRef<ContainedObject>*)p);
10176  }
10177  static void destruct_SmartReflEContainedObjectgR(void *p) {
10178  typedef ::SmartRef<ContainedObject> current_t;
10179  ((current_t*)p)->~current_t();
10180  }
10181 } // end of namespace ROOT for class ::SmartRef<ContainedObject>
10182 
10183 namespace ROOT {
10184  // Wrappers around operator new
10185  static void *new_SmartReflEObjectContainerBasegR(void *p) {
10186  return p ? new(p) ::SmartRef<ObjectContainerBase> : new ::SmartRef<ObjectContainerBase>;
10187  }
10188  static void *newArray_SmartReflEObjectContainerBasegR(Long_t nElements, void *p) {
10189  return p ? new(p) ::SmartRef<ObjectContainerBase>[nElements] : new ::SmartRef<ObjectContainerBase>[nElements];
10190  }
10191  // Wrapper around operator delete
10192  static void delete_SmartReflEObjectContainerBasegR(void *p) {
10193  delete ((::SmartRef<ObjectContainerBase>*)p);
10194  }
10195  static void deleteArray_SmartReflEObjectContainerBasegR(void *p) {
10196  delete [] ((::SmartRef<ObjectContainerBase>*)p);
10197  }
10198  static void destruct_SmartReflEObjectContainerBasegR(void *p) {
10199  typedef ::SmartRef<ObjectContainerBase> current_t;
10200  ((current_t*)p)->~current_t();
10201  }
10202 } // end of namespace ROOT for class ::SmartRef<ObjectContainerBase>
10203 
10204 namespace ROOT {
10205  // Wrappers around operator new
10206  static void *new_SmartReflEKeyedObjectlEintgRsPgR(void *p) {
10207  return p ? new(p) ::SmartRef<KeyedObject<int> > : new ::SmartRef<KeyedObject<int> >;
10208  }
10209  static void *newArray_SmartReflEKeyedObjectlEintgRsPgR(Long_t nElements, void *p) {
10210  return p ? new(p) ::SmartRef<KeyedObject<int> >[nElements] : new ::SmartRef<KeyedObject<int> >[nElements];
10211  }
10212  // Wrapper around operator delete
10213  static void delete_SmartReflEKeyedObjectlEintgRsPgR(void *p) {
10214  delete ((::SmartRef<KeyedObject<int> >*)p);
10215  }
10216  static void deleteArray_SmartReflEKeyedObjectlEintgRsPgR(void *p) {
10217  delete [] ((::SmartRef<KeyedObject<int> >*)p);
10218  }
10219  static void destruct_SmartReflEKeyedObjectlEintgRsPgR(void *p) {
10220  typedef ::SmartRef<KeyedObject<int> > current_t;
10221  ((current_t*)p)->~current_t();
10222  }
10223 } // end of namespace ROOT for class ::SmartRef<KeyedObject<int> >
10224 
10225 namespace ROOT {
10226  // Wrappers around operator new
10227  static void *new_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
10228  return p ? new(p) ::SmartRef<KeyedObject<unsigned int> > : new ::SmartRef<KeyedObject<unsigned int> >;
10229  }
10230  static void *newArray_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(Long_t nElements, void *p) {
10231  return p ? new(p) ::SmartRef<KeyedObject<unsigned int> >[nElements] : new ::SmartRef<KeyedObject<unsigned int> >[nElements];
10232  }
10233  // Wrapper around operator delete
10234  static void delete_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
10235  delete ((::SmartRef<KeyedObject<unsigned int> >*)p);
10236  }
10237  static void deleteArray_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
10238  delete [] ((::SmartRef<KeyedObject<unsigned int> >*)p);
10239  }
10240  static void destruct_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
10241  typedef ::SmartRef<KeyedObject<unsigned int> > current_t;
10242  ((current_t*)p)->~current_t();
10243  }
10244 } // end of namespace ROOT for class ::SmartRef<KeyedObject<unsigned int> >
10245 
10246 namespace ROOT {
10247  // Wrappers around operator new
10248  static void *new_SmartReflEKeyedObjectlElonggRsPgR(void *p) {
10249  return p ? new(p) ::SmartRef<KeyedObject<long> > : new ::SmartRef<KeyedObject<long> >;
10250  }
10251  static void *newArray_SmartReflEKeyedObjectlElonggRsPgR(Long_t nElements, void *p) {
10252  return p ? new(p) ::SmartRef<KeyedObject<long> >[nElements] : new ::SmartRef<KeyedObject<long> >[nElements];
10253  }
10254  // Wrapper around operator delete
10255  static void delete_SmartReflEKeyedObjectlElonggRsPgR(void *p) {
10256  delete ((::SmartRef<KeyedObject<long> >*)p);
10257  }
10258  static void deleteArray_SmartReflEKeyedObjectlElonggRsPgR(void *p) {
10259  delete [] ((::SmartRef<KeyedObject<long> >*)p);
10260  }
10261  static void destruct_SmartReflEKeyedObjectlElonggRsPgR(void *p) {
10262  typedef ::SmartRef<KeyedObject<long> > current_t;
10263  ((current_t*)p)->~current_t();
10264  }
10265 } // end of namespace ROOT for class ::SmartRef<KeyedObject<long> >
10266 
10267 namespace ROOT {
10268  // Wrappers around operator new
10269  static void *new_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
10270  return p ? new(p) ::SmartRef<KeyedObject<unsigned long> > : new ::SmartRef<KeyedObject<unsigned long> >;
10271  }
10272  static void *newArray_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(Long_t nElements, void *p) {
10273  return p ? new(p) ::SmartRef<KeyedObject<unsigned long> >[nElements] : new ::SmartRef<KeyedObject<unsigned long> >[nElements];
10274  }
10275  // Wrapper around operator delete
10276  static void delete_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
10277  delete ((::SmartRef<KeyedObject<unsigned long> >*)p);
10278  }
10279  static void deleteArray_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
10280  delete [] ((::SmartRef<KeyedObject<unsigned long> >*)p);
10281  }
10282  static void destruct_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
10283  typedef ::SmartRef<KeyedObject<unsigned long> > current_t;
10284  ((current_t*)p)->~current_t();
10285  }
10286 } // end of namespace ROOT for class ::SmartRef<KeyedObject<unsigned long> >
10287 
10288 namespace ROOT {
10289  // Wrapper around operator delete
10290  static void delete_INTuple(void *p) {
10291  delete ((::INTuple*)p);
10292  }
10293  static void deleteArray_INTuple(void *p) {
10294  delete [] ((::INTuple*)p);
10295  }
10296  static void destruct_INTuple(void *p) {
10297  typedef ::INTuple current_t;
10298  ((current_t*)p)->~current_t();
10299  }
10300 } // end of namespace ROOT for class ::INTuple
10301 
10302 namespace ROOT {
10303  // Wrapper around operator delete
10304  static void delete_SmartDataObjectPtr(void *p) {
10305  delete ((::SmartDataObjectPtr*)p);
10306  }
10307  static void deleteArray_SmartDataObjectPtr(void *p) {
10308  delete [] ((::SmartDataObjectPtr*)p);
10309  }
10310  static void destruct_SmartDataObjectPtr(void *p) {
10311  typedef ::SmartDataObjectPtr current_t;
10312  ((current_t*)p)->~current_t();
10313  }
10314 } // end of namespace ROOT for class ::SmartDataObjectPtr
10315 
10316 namespace ROOT {
10317  // Wrappers around operator new
10318  static void *new_SmartDataObjectPtrcLcLObjectLoader(void *p) {
10319  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::SmartDataObjectPtr::ObjectLoader : new ::SmartDataObjectPtr::ObjectLoader;
10320  }
10321  static void *newArray_SmartDataObjectPtrcLcLObjectLoader(Long_t nElements, void *p) {
10322  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::SmartDataObjectPtr::ObjectLoader[nElements] : new ::SmartDataObjectPtr::ObjectLoader[nElements];
10323  }
10324  // Wrapper around operator delete
10325  static void delete_SmartDataObjectPtrcLcLObjectLoader(void *p) {
10326  delete ((::SmartDataObjectPtr::ObjectLoader*)p);
10327  }
10328  static void deleteArray_SmartDataObjectPtrcLcLObjectLoader(void *p) {
10329  delete [] ((::SmartDataObjectPtr::ObjectLoader*)p);
10330  }
10331  static void destruct_SmartDataObjectPtrcLcLObjectLoader(void *p) {
10332  typedef ::SmartDataObjectPtr::ObjectLoader current_t;
10333  ((current_t*)p)->~current_t();
10334  }
10335 } // end of namespace ROOT for class ::SmartDataObjectPtr::ObjectLoader
10336 
10337 namespace ROOT {
10338  // Wrappers around operator new
10339  static void *new_SmartDataObjectPtrcLcLObjectFinder(void *p) {
10340  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::SmartDataObjectPtr::ObjectFinder : new ::SmartDataObjectPtr::ObjectFinder;
10341  }
10342  static void *newArray_SmartDataObjectPtrcLcLObjectFinder(Long_t nElements, void *p) {
10343  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::SmartDataObjectPtr::ObjectFinder[nElements] : new ::SmartDataObjectPtr::ObjectFinder[nElements];
10344  }
10345  // Wrapper around operator delete
10346  static void delete_SmartDataObjectPtrcLcLObjectFinder(void *p) {
10347  delete ((::SmartDataObjectPtr::ObjectFinder*)p);
10348  }
10349  static void deleteArray_SmartDataObjectPtrcLcLObjectFinder(void *p) {
10350  delete [] ((::SmartDataObjectPtr::ObjectFinder*)p);
10351  }
10352  static void destruct_SmartDataObjectPtrcLcLObjectFinder(void *p) {
10353  typedef ::SmartDataObjectPtr::ObjectFinder current_t;
10354  ((current_t*)p)->~current_t();
10355  }
10356 } // end of namespace ROOT for class ::SmartDataObjectPtr::ObjectFinder
10357 
10358 namespace ROOT {
10359  // Wrapper around operator delete
10360  static void delete_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR(void *p) {
10361  delete ((::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)p);
10362  }
10363  static void deleteArray_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR(void *p) {
10364  delete [] ((::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)p);
10365  }
10366  static void destruct_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR(void *p) {
10367  typedef ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader> current_t;
10368  ((current_t*)p)->~current_t();
10369  }
10370 } // end of namespace ROOT for class ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>
10371 
10372 namespace ROOT {
10373  // Wrapper around operator delete
10374  static void delete_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR(void *p) {
10375  delete ((::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)p);
10376  }
10377  static void deleteArray_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR(void *p) {
10378  delete [] ((::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)p);
10379  }
10380  static void destruct_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR(void *p) {
10381  typedef ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader> current_t;
10382  ((current_t*)p)->~current_t();
10383  }
10384 } // end of namespace ROOT for class ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>
10385 
10386 namespace ROOT {
10387  // Wrapper around operator delete
10388  static void delete_SmartDataPtrlEDataObjectgR(void *p) {
10389  delete ((::SmartDataPtr<DataObject>*)p);
10390  }
10391  static void deleteArray_SmartDataPtrlEDataObjectgR(void *p) {
10392  delete [] ((::SmartDataPtr<DataObject>*)p);
10393  }
10394  static void destruct_SmartDataPtrlEDataObjectgR(void *p) {
10395  typedef ::SmartDataPtr<DataObject> current_t;
10396  ((current_t*)p)->~current_t();
10397  }
10398 } // end of namespace ROOT for class ::SmartDataPtr<DataObject>
10399 
10400 namespace ROOT {
10401  // Wrapper around operator delete
10402  static void delete_SmartDataPtrlEObjectContainerBasegR(void *p) {
10403  delete ((::SmartDataPtr<ObjectContainerBase>*)p);
10404  }
10405  static void deleteArray_SmartDataPtrlEObjectContainerBasegR(void *p) {
10406  delete [] ((::SmartDataPtr<ObjectContainerBase>*)p);
10407  }
10408  static void destruct_SmartDataPtrlEObjectContainerBasegR(void *p) {
10409  typedef ::SmartDataPtr<ObjectContainerBase> current_t;
10410  ((current_t*)p)->~current_t();
10411  }
10412 } // end of namespace ROOT for class ::SmartDataPtr<ObjectContainerBase>
10413 
10414 namespace ROOT {
10415  // Wrappers around operator new
10416  static void *new_NTuplecLcLItemlEchargR(void *p) {
10417  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<char> : new ::NTuple::Item<char>;
10418  }
10419  static void *newArray_NTuplecLcLItemlEchargR(Long_t nElements, void *p) {
10420  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<char>[nElements] : new ::NTuple::Item<char>[nElements];
10421  }
10422  // Wrapper around operator delete
10423  static void delete_NTuplecLcLItemlEchargR(void *p) {
10424  delete ((::NTuple::Item<char>*)p);
10425  }
10426  static void deleteArray_NTuplecLcLItemlEchargR(void *p) {
10427  delete [] ((::NTuple::Item<char>*)p);
10428  }
10429  static void destruct_NTuplecLcLItemlEchargR(void *p) {
10430  typedef ::NTuple::Item<char> current_t;
10431  ((current_t*)p)->~current_t();
10432  }
10433 } // end of namespace ROOT for class ::NTuple::Item<char>
10434 
10435 namespace ROOT {
10436  // Wrappers around operator new
10437  static void *new_NTuplecLcLItemlEunsignedsPchargR(void *p) {
10438  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned char> : new ::NTuple::Item<unsigned char>;
10439  }
10440  static void *newArray_NTuplecLcLItemlEunsignedsPchargR(Long_t nElements, void *p) {
10441  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned char>[nElements] : new ::NTuple::Item<unsigned char>[nElements];
10442  }
10443  // Wrapper around operator delete
10444  static void delete_NTuplecLcLItemlEunsignedsPchargR(void *p) {
10445  delete ((::NTuple::Item<unsigned char>*)p);
10446  }
10447  static void deleteArray_NTuplecLcLItemlEunsignedsPchargR(void *p) {
10448  delete [] ((::NTuple::Item<unsigned char>*)p);
10449  }
10450  static void destruct_NTuplecLcLItemlEunsignedsPchargR(void *p) {
10451  typedef ::NTuple::Item<unsigned char> current_t;
10452  ((current_t*)p)->~current_t();
10453  }
10454 } // end of namespace ROOT for class ::NTuple::Item<unsigned char>
10455 
10456 namespace ROOT {
10457  // Wrappers around operator new
10458  static void *new_NTuplecLcLItemlEshortgR(void *p) {
10459  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<short> : new ::NTuple::Item<short>;
10460  }
10461  static void *newArray_NTuplecLcLItemlEshortgR(Long_t nElements, void *p) {
10462  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<short>[nElements] : new ::NTuple::Item<short>[nElements];
10463  }
10464  // Wrapper around operator delete
10465  static void delete_NTuplecLcLItemlEshortgR(void *p) {
10466  delete ((::NTuple::Item<short>*)p);
10467  }
10468  static void deleteArray_NTuplecLcLItemlEshortgR(void *p) {
10469  delete [] ((::NTuple::Item<short>*)p);
10470  }
10471  static void destruct_NTuplecLcLItemlEshortgR(void *p) {
10472  typedef ::NTuple::Item<short> current_t;
10473  ((current_t*)p)->~current_t();
10474  }
10475 } // end of namespace ROOT for class ::NTuple::Item<short>
10476 
10477 namespace ROOT {
10478  // Wrappers around operator new
10479  static void *new_NTuplecLcLItemlEunsignedsPshortgR(void *p) {
10480  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned short> : new ::NTuple::Item<unsigned short>;
10481  }
10482  static void *newArray_NTuplecLcLItemlEunsignedsPshortgR(Long_t nElements, void *p) {
10483  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned short>[nElements] : new ::NTuple::Item<unsigned short>[nElements];
10484  }
10485  // Wrapper around operator delete
10486  static void delete_NTuplecLcLItemlEunsignedsPshortgR(void *p) {
10487  delete ((::NTuple::Item<unsigned short>*)p);
10488  }
10489  static void deleteArray_NTuplecLcLItemlEunsignedsPshortgR(void *p) {
10490  delete [] ((::NTuple::Item<unsigned short>*)p);
10491  }
10492  static void destruct_NTuplecLcLItemlEunsignedsPshortgR(void *p) {
10493  typedef ::NTuple::Item<unsigned short> current_t;
10494  ((current_t*)p)->~current_t();
10495  }
10496 } // end of namespace ROOT for class ::NTuple::Item<unsigned short>
10497 
10498 namespace ROOT {
10499  // Wrappers around operator new
10500  static void *new_NTuplecLcLItemlElonggR(void *p) {
10501  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<long> : new ::NTuple::Item<long>;
10502  }
10503  static void *newArray_NTuplecLcLItemlElonggR(Long_t nElements, void *p) {
10504  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<long>[nElements] : new ::NTuple::Item<long>[nElements];
10505  }
10506  // Wrapper around operator delete
10507  static void delete_NTuplecLcLItemlElonggR(void *p) {
10508  delete ((::NTuple::Item<long>*)p);
10509  }
10510  static void deleteArray_NTuplecLcLItemlElonggR(void *p) {
10511  delete [] ((::NTuple::Item<long>*)p);
10512  }
10513  static void destruct_NTuplecLcLItemlElonggR(void *p) {
10514  typedef ::NTuple::Item<long> current_t;
10515  ((current_t*)p)->~current_t();
10516  }
10517 } // end of namespace ROOT for class ::NTuple::Item<long>
10518 
10519 namespace ROOT {
10520  // Wrappers around operator new
10521  static void *new_NTuplecLcLItemlELong64_tgR(void *p) {
10522  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<Long64_t> : new ::NTuple::Item<Long64_t>;
10523  }
10524  static void *newArray_NTuplecLcLItemlELong64_tgR(Long_t nElements, void *p) {
10525  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<Long64_t>[nElements] : new ::NTuple::Item<Long64_t>[nElements];
10526  }
10527  // Wrapper around operator delete
10528  static void delete_NTuplecLcLItemlELong64_tgR(void *p) {
10529  delete ((::NTuple::Item<Long64_t>*)p);
10530  }
10531  static void deleteArray_NTuplecLcLItemlELong64_tgR(void *p) {
10532  delete [] ((::NTuple::Item<Long64_t>*)p);
10533  }
10534  static void destruct_NTuplecLcLItemlELong64_tgR(void *p) {
10535  typedef ::NTuple::Item<Long64_t> current_t;
10536  ((current_t*)p)->~current_t();
10537  }
10538 } // end of namespace ROOT for class ::NTuple::Item<Long64_t>
10539 
10540 namespace ROOT {
10541  // Wrappers around operator new
10542  static void *new_NTuplecLcLItemlEunsignedsPlonggR(void *p) {
10543  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned long> : new ::NTuple::Item<unsigned long>;
10544  }
10545  static void *newArray_NTuplecLcLItemlEunsignedsPlonggR(Long_t nElements, void *p) {
10546  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned long>[nElements] : new ::NTuple::Item<unsigned long>[nElements];
10547  }
10548  // Wrapper around operator delete
10549  static void delete_NTuplecLcLItemlEunsignedsPlonggR(void *p) {
10550  delete ((::NTuple::Item<unsigned long>*)p);
10551  }
10552  static void deleteArray_NTuplecLcLItemlEunsignedsPlonggR(void *p) {
10553  delete [] ((::NTuple::Item<unsigned long>*)p);
10554  }
10555  static void destruct_NTuplecLcLItemlEunsignedsPlonggR(void *p) {
10556  typedef ::NTuple::Item<unsigned long> current_t;
10557  ((current_t*)p)->~current_t();
10558  }
10559 } // end of namespace ROOT for class ::NTuple::Item<unsigned long>
10560 
10561 namespace ROOT {
10562  // Wrappers around operator new
10563  static void *new_NTuplecLcLItemlEULong64_tgR(void *p) {
10564  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<ULong64_t> : new ::NTuple::Item<ULong64_t>;
10565  }
10566  static void *newArray_NTuplecLcLItemlEULong64_tgR(Long_t nElements, void *p) {
10567  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<ULong64_t>[nElements] : new ::NTuple::Item<ULong64_t>[nElements];
10568  }
10569  // Wrapper around operator delete
10570  static void delete_NTuplecLcLItemlEULong64_tgR(void *p) {
10571  delete ((::NTuple::Item<ULong64_t>*)p);
10572  }
10573  static void deleteArray_NTuplecLcLItemlEULong64_tgR(void *p) {
10574  delete [] ((::NTuple::Item<ULong64_t>*)p);
10575  }
10576  static void destruct_NTuplecLcLItemlEULong64_tgR(void *p) {
10577  typedef ::NTuple::Item<ULong64_t> current_t;
10578  ((current_t*)p)->~current_t();
10579  }
10580 } // end of namespace ROOT for class ::NTuple::Item<ULong64_t>
10581 
10582 namespace ROOT {
10583  // Wrappers around operator new
10584  static void *new_NTuplecLcLItemlEintgR(void *p) {
10585  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<int> : new ::NTuple::Item<int>;
10586  }
10587  static void *newArray_NTuplecLcLItemlEintgR(Long_t nElements, void *p) {
10588  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<int>[nElements] : new ::NTuple::Item<int>[nElements];
10589  }
10590  // Wrapper around operator delete
10591  static void delete_NTuplecLcLItemlEintgR(void *p) {
10592  delete ((::NTuple::Item<int>*)p);
10593  }
10594  static void deleteArray_NTuplecLcLItemlEintgR(void *p) {
10595  delete [] ((::NTuple::Item<int>*)p);
10596  }
10597  static void destruct_NTuplecLcLItemlEintgR(void *p) {
10598  typedef ::NTuple::Item<int> current_t;
10599  ((current_t*)p)->~current_t();
10600  }
10601 } // end of namespace ROOT for class ::NTuple::Item<int>
10602 
10603 namespace ROOT {
10604  // Wrappers around operator new
10605  static void *new_NTuplecLcLItemlEunsignedsPintgR(void *p) {
10606  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned int> : new ::NTuple::Item<unsigned int>;
10607  }
10608  static void *newArray_NTuplecLcLItemlEunsignedsPintgR(Long_t nElements, void *p) {
10609  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned int>[nElements] : new ::NTuple::Item<unsigned int>[nElements];
10610  }
10611  // Wrapper around operator delete
10612  static void delete_NTuplecLcLItemlEunsignedsPintgR(void *p) {
10613  delete ((::NTuple::Item<unsigned int>*)p);
10614  }
10615  static void deleteArray_NTuplecLcLItemlEunsignedsPintgR(void *p) {
10616  delete [] ((::NTuple::Item<unsigned int>*)p);
10617  }
10618  static void destruct_NTuplecLcLItemlEunsignedsPintgR(void *p) {
10619  typedef ::NTuple::Item<unsigned int> current_t;
10620  ((current_t*)p)->~current_t();
10621  }
10622 } // end of namespace ROOT for class ::NTuple::Item<unsigned int>
10623 
10624 namespace ROOT {
10625  // Wrappers around operator new
10626  static void *new_NTuplecLcLItemlEfloatgR(void *p) {
10627  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<float> : new ::NTuple::Item<float>;
10628  }
10629  static void *newArray_NTuplecLcLItemlEfloatgR(Long_t nElements, void *p) {
10630  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<float>[nElements] : new ::NTuple::Item<float>[nElements];
10631  }
10632  // Wrapper around operator delete
10633  static void delete_NTuplecLcLItemlEfloatgR(void *p) {
10634  delete ((::NTuple::Item<float>*)p);
10635  }
10636  static void deleteArray_NTuplecLcLItemlEfloatgR(void *p) {
10637  delete [] ((::NTuple::Item<float>*)p);
10638  }
10639  static void destruct_NTuplecLcLItemlEfloatgR(void *p) {
10640  typedef ::NTuple::Item<float> current_t;
10641  ((current_t*)p)->~current_t();
10642  }
10643 } // end of namespace ROOT for class ::NTuple::Item<float>
10644 
10645 namespace ROOT {
10646  // Wrappers around operator new
10647  static void *new_NTuplecLcLItemlEdoublegR(void *p) {
10648  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<double> : new ::NTuple::Item<double>;
10649  }
10650  static void *newArray_NTuplecLcLItemlEdoublegR(Long_t nElements, void *p) {
10651  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<double>[nElements] : new ::NTuple::Item<double>[nElements];
10652  }
10653  // Wrapper around operator delete
10654  static void delete_NTuplecLcLItemlEdoublegR(void *p) {
10655  delete ((::NTuple::Item<double>*)p);
10656  }
10657  static void deleteArray_NTuplecLcLItemlEdoublegR(void *p) {
10658  delete [] ((::NTuple::Item<double>*)p);
10659  }
10660  static void destruct_NTuplecLcLItemlEdoublegR(void *p) {
10661  typedef ::NTuple::Item<double> current_t;
10662  ((current_t*)p)->~current_t();
10663  }
10664 } // end of namespace ROOT for class ::NTuple::Item<double>
10665 
10666 namespace ROOT {
10667  // Wrappers around operator new
10668  static void *new_NTuplecLcLArraylEboolgR(void *p) {
10669  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<bool> : new ::NTuple::Array<bool>;
10670  }
10671  static void *newArray_NTuplecLcLArraylEboolgR(Long_t nElements, void *p) {
10672  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<bool>[nElements] : new ::NTuple::Array<bool>[nElements];
10673  }
10674  // Wrapper around operator delete
10675  static void delete_NTuplecLcLArraylEboolgR(void *p) {
10676  delete ((::NTuple::Array<bool>*)p);
10677  }
10678  static void deleteArray_NTuplecLcLArraylEboolgR(void *p) {
10679  delete [] ((::NTuple::Array<bool>*)p);
10680  }
10681  static void destruct_NTuplecLcLArraylEboolgR(void *p) {
10682  typedef ::NTuple::Array<bool> current_t;
10683  ((current_t*)p)->~current_t();
10684  }
10685 } // end of namespace ROOT for class ::NTuple::Array<bool>
10686 
10687 namespace ROOT {
10688  // Wrappers around operator new
10689  static void *new_NTuplecLcLArraylEchargR(void *p) {
10690  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<char> : new ::NTuple::Array<char>;
10691  }
10692  static void *newArray_NTuplecLcLArraylEchargR(Long_t nElements, void *p) {
10693  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<char>[nElements] : new ::NTuple::Array<char>[nElements];
10694  }
10695  // Wrapper around operator delete
10696  static void delete_NTuplecLcLArraylEchargR(void *p) {
10697  delete ((::NTuple::Array<char>*)p);
10698  }
10699  static void deleteArray_NTuplecLcLArraylEchargR(void *p) {
10700  delete [] ((::NTuple::Array<char>*)p);
10701  }
10702  static void destruct_NTuplecLcLArraylEchargR(void *p) {
10703  typedef ::NTuple::Array<char> current_t;
10704  ((current_t*)p)->~current_t();
10705  }
10706 } // end of namespace ROOT for class ::NTuple::Array<char>
10707 
10708 namespace ROOT {
10709  // Wrappers around operator new
10710  static void *new_NTuplecLcLArraylEunsignedsPchargR(void *p) {
10711  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned char> : new ::NTuple::Array<unsigned char>;
10712  }
10713  static void *newArray_NTuplecLcLArraylEunsignedsPchargR(Long_t nElements, void *p) {
10714  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned char>[nElements] : new ::NTuple::Array<unsigned char>[nElements];
10715  }
10716  // Wrapper around operator delete
10717  static void delete_NTuplecLcLArraylEunsignedsPchargR(void *p) {
10718  delete ((::NTuple::Array<unsigned char>*)p);
10719  }
10720  static void deleteArray_NTuplecLcLArraylEunsignedsPchargR(void *p) {
10721  delete [] ((::NTuple::Array<unsigned char>*)p);
10722  }
10723  static void destruct_NTuplecLcLArraylEunsignedsPchargR(void *p) {
10724  typedef ::NTuple::Array<unsigned char> current_t;
10725  ((current_t*)p)->~current_t();
10726  }
10727 } // end of namespace ROOT for class ::NTuple::Array<unsigned char>
10728 
10729 namespace ROOT {
10730  // Wrappers around operator new
10731  static void *new_NTuplecLcLArraylEshortgR(void *p) {
10732  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<short> : new ::NTuple::Array<short>;
10733  }
10734  static void *newArray_NTuplecLcLArraylEshortgR(Long_t nElements, void *p) {
10735  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<short>[nElements] : new ::NTuple::Array<short>[nElements];
10736  }
10737  // Wrapper around operator delete
10738  static void delete_NTuplecLcLArraylEshortgR(void *p) {
10739  delete ((::NTuple::Array<short>*)p);
10740  }
10741  static void deleteArray_NTuplecLcLArraylEshortgR(void *p) {
10742  delete [] ((::NTuple::Array<short>*)p);
10743  }
10744  static void destruct_NTuplecLcLArraylEshortgR(void *p) {
10745  typedef ::NTuple::Array<short> current_t;
10746  ((current_t*)p)->~current_t();
10747  }
10748 } // end of namespace ROOT for class ::NTuple::Array<short>
10749 
10750 namespace ROOT {
10751  // Wrappers around operator new
10752  static void *new_NTuplecLcLArraylEunsignedsPshortgR(void *p) {
10753  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned short> : new ::NTuple::Array<unsigned short>;
10754  }
10755  static void *newArray_NTuplecLcLArraylEunsignedsPshortgR(Long_t nElements, void *p) {
10756  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned short>[nElements] : new ::NTuple::Array<unsigned short>[nElements];
10757  }
10758  // Wrapper around operator delete
10759  static void delete_NTuplecLcLArraylEunsignedsPshortgR(void *p) {
10760  delete ((::NTuple::Array<unsigned short>*)p);
10761  }
10762  static void deleteArray_NTuplecLcLArraylEunsignedsPshortgR(void *p) {
10763  delete [] ((::NTuple::Array<unsigned short>*)p);
10764  }
10765  static void destruct_NTuplecLcLArraylEunsignedsPshortgR(void *p) {
10766  typedef ::NTuple::Array<unsigned short> current_t;
10767  ((current_t*)p)->~current_t();
10768  }
10769 } // end of namespace ROOT for class ::NTuple::Array<unsigned short>
10770 
10771 namespace ROOT {
10772  // Wrappers around operator new
10773  static void *new_NTuplecLcLArraylElonggR(void *p) {
10774  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<long> : new ::NTuple::Array<long>;
10775  }
10776  static void *newArray_NTuplecLcLArraylElonggR(Long_t nElements, void *p) {
10777  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<long>[nElements] : new ::NTuple::Array<long>[nElements];
10778  }
10779  // Wrapper around operator delete
10780  static void delete_NTuplecLcLArraylElonggR(void *p) {
10781  delete ((::NTuple::Array<long>*)p);
10782  }
10783  static void deleteArray_NTuplecLcLArraylElonggR(void *p) {
10784  delete [] ((::NTuple::Array<long>*)p);
10785  }
10786  static void destruct_NTuplecLcLArraylElonggR(void *p) {
10787  typedef ::NTuple::Array<long> current_t;
10788  ((current_t*)p)->~current_t();
10789  }
10790 } // end of namespace ROOT for class ::NTuple::Array<long>
10791 
10792 namespace ROOT {
10793  // Wrappers around operator new
10794  static void *new_NTuplecLcLArraylEunsignedsPlonggR(void *p) {
10795  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned long> : new ::NTuple::Array<unsigned long>;
10796  }
10797  static void *newArray_NTuplecLcLArraylEunsignedsPlonggR(Long_t nElements, void *p) {
10798  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned long>[nElements] : new ::NTuple::Array<unsigned long>[nElements];
10799  }
10800  // Wrapper around operator delete
10801  static void delete_NTuplecLcLArraylEunsignedsPlonggR(void *p) {
10802  delete ((::NTuple::Array<unsigned long>*)p);
10803  }
10804  static void deleteArray_NTuplecLcLArraylEunsignedsPlonggR(void *p) {
10805  delete [] ((::NTuple::Array<unsigned long>*)p);
10806  }
10807  static void destruct_NTuplecLcLArraylEunsignedsPlonggR(void *p) {
10808  typedef ::NTuple::Array<unsigned long> current_t;
10809  ((current_t*)p)->~current_t();
10810  }
10811 } // end of namespace ROOT for class ::NTuple::Array<unsigned long>
10812 
10813 namespace ROOT {
10814  // Wrappers around operator new
10815  static void *new_NTuplecLcLArraylEintgR(void *p) {
10816  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<int> : new ::NTuple::Array<int>;
10817  }
10818  static void *newArray_NTuplecLcLArraylEintgR(Long_t nElements, void *p) {
10819  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<int>[nElements] : new ::NTuple::Array<int>[nElements];
10820  }
10821  // Wrapper around operator delete
10822  static void delete_NTuplecLcLArraylEintgR(void *p) {
10823  delete ((::NTuple::Array<int>*)p);
10824  }
10825  static void deleteArray_NTuplecLcLArraylEintgR(void *p) {
10826  delete [] ((::NTuple::Array<int>*)p);
10827  }
10828  static void destruct_NTuplecLcLArraylEintgR(void *p) {
10829  typedef ::NTuple::Array<int> current_t;
10830  ((current_t*)p)->~current_t();
10831  }
10832 } // end of namespace ROOT for class ::NTuple::Array<int>
10833 
10834 namespace ROOT {
10835  // Wrappers around operator new
10836  static void *new_NTuplecLcLArraylEunsignedsPintgR(void *p) {
10837  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned int> : new ::NTuple::Array<unsigned int>;
10838  }
10839  static void *newArray_NTuplecLcLArraylEunsignedsPintgR(Long_t nElements, void *p) {
10840  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned int>[nElements] : new ::NTuple::Array<unsigned int>[nElements];
10841  }
10842  // Wrapper around operator delete
10843  static void delete_NTuplecLcLArraylEunsignedsPintgR(void *p) {
10844  delete ((::NTuple::Array<unsigned int>*)p);
10845  }
10846  static void deleteArray_NTuplecLcLArraylEunsignedsPintgR(void *p) {
10847  delete [] ((::NTuple::Array<unsigned int>*)p);
10848  }
10849  static void destruct_NTuplecLcLArraylEunsignedsPintgR(void *p) {
10850  typedef ::NTuple::Array<unsigned int> current_t;
10851  ((current_t*)p)->~current_t();
10852  }
10853 } // end of namespace ROOT for class ::NTuple::Array<unsigned int>
10854 
10855 namespace ROOT {
10856  // Wrappers around operator new
10857  static void *new_NTuplecLcLArraylEfloatgR(void *p) {
10858  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<float> : new ::NTuple::Array<float>;
10859  }
10860  static void *newArray_NTuplecLcLArraylEfloatgR(Long_t nElements, void *p) {
10861  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<float>[nElements] : new ::NTuple::Array<float>[nElements];
10862  }
10863  // Wrapper around operator delete
10864  static void delete_NTuplecLcLArraylEfloatgR(void *p) {
10865  delete ((::NTuple::Array<float>*)p);
10866  }
10867  static void deleteArray_NTuplecLcLArraylEfloatgR(void *p) {
10868  delete [] ((::NTuple::Array<float>*)p);
10869  }
10870  static void destruct_NTuplecLcLArraylEfloatgR(void *p) {
10871  typedef ::NTuple::Array<float> current_t;
10872  ((current_t*)p)->~current_t();
10873  }
10874 } // end of namespace ROOT for class ::NTuple::Array<float>
10875 
10876 namespace ROOT {
10877  // Wrappers around operator new
10878  static void *new_NTuplecLcLArraylEdoublegR(void *p) {
10879  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<double> : new ::NTuple::Array<double>;
10880  }
10881  static void *newArray_NTuplecLcLArraylEdoublegR(Long_t nElements, void *p) {
10882  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<double>[nElements] : new ::NTuple::Array<double>[nElements];
10883  }
10884  // Wrapper around operator delete
10885  static void delete_NTuplecLcLArraylEdoublegR(void *p) {
10886  delete ((::NTuple::Array<double>*)p);
10887  }
10888  static void deleteArray_NTuplecLcLArraylEdoublegR(void *p) {
10889  delete [] ((::NTuple::Array<double>*)p);
10890  }
10891  static void destruct_NTuplecLcLArraylEdoublegR(void *p) {
10892  typedef ::NTuple::Array<double> current_t;
10893  ((current_t*)p)->~current_t();
10894  }
10895 } // end of namespace ROOT for class ::NTuple::Array<double>
10896 
10897 namespace ROOT {
10898  // Wrappers around operator new
10899  static void *new_NTuplecLcLMatrixlEboolgR(void *p) {
10900  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<bool> : new ::NTuple::Matrix<bool>;
10901  }
10902  static void *newArray_NTuplecLcLMatrixlEboolgR(Long_t nElements, void *p) {
10903  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<bool>[nElements] : new ::NTuple::Matrix<bool>[nElements];
10904  }
10905  // Wrapper around operator delete
10906  static void delete_NTuplecLcLMatrixlEboolgR(void *p) {
10907  delete ((::NTuple::Matrix<bool>*)p);
10908  }
10909  static void deleteArray_NTuplecLcLMatrixlEboolgR(void *p) {
10910  delete [] ((::NTuple::Matrix<bool>*)p);
10911  }
10912  static void destruct_NTuplecLcLMatrixlEboolgR(void *p) {
10913  typedef ::NTuple::Matrix<bool> current_t;
10914  ((current_t*)p)->~current_t();
10915  }
10916 } // end of namespace ROOT for class ::NTuple::Matrix<bool>
10917 
10918 namespace ROOT {
10919  // Wrappers around operator new
10920  static void *new_NTuplecLcLMatrixlEchargR(void *p) {
10921  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<char> : new ::NTuple::Matrix<char>;
10922  }
10923  static void *newArray_NTuplecLcLMatrixlEchargR(Long_t nElements, void *p) {
10924  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<char>[nElements] : new ::NTuple::Matrix<char>[nElements];
10925  }
10926  // Wrapper around operator delete
10927  static void delete_NTuplecLcLMatrixlEchargR(void *p) {
10928  delete ((::NTuple::Matrix<char>*)p);
10929  }
10930  static void deleteArray_NTuplecLcLMatrixlEchargR(void *p) {
10931  delete [] ((::NTuple::Matrix<char>*)p);
10932  }
10933  static void destruct_NTuplecLcLMatrixlEchargR(void *p) {
10934  typedef ::NTuple::Matrix<char> current_t;
10935  ((current_t*)p)->~current_t();
10936  }
10937 } // end of namespace ROOT for class ::NTuple::Matrix<char>
10938 
10939 namespace ROOT {
10940  // Wrappers around operator new
10941  static void *new_NTuplecLcLMatrixlEunsignedsPchargR(void *p) {
10942  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned char> : new ::NTuple::Matrix<unsigned char>;
10943  }
10944  static void *newArray_NTuplecLcLMatrixlEunsignedsPchargR(Long_t nElements, void *p) {
10945  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned char>[nElements] : new ::NTuple::Matrix<unsigned char>[nElements];
10946  }
10947  // Wrapper around operator delete
10948  static void delete_NTuplecLcLMatrixlEunsignedsPchargR(void *p) {
10949  delete ((::NTuple::Matrix<unsigned char>*)p);
10950  }
10951  static void deleteArray_NTuplecLcLMatrixlEunsignedsPchargR(void *p) {
10952  delete [] ((::NTuple::Matrix<unsigned char>*)p);
10953  }
10954  static void destruct_NTuplecLcLMatrixlEunsignedsPchargR(void *p) {
10955  typedef ::NTuple::Matrix<unsigned char> current_t;
10956  ((current_t*)p)->~current_t();
10957  }
10958 } // end of namespace ROOT for class ::NTuple::Matrix<unsigned char>
10959 
10960 namespace ROOT {
10961  // Wrappers around operator new
10962  static void *new_NTuplecLcLMatrixlEshortgR(void *p) {
10963  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<short> : new ::NTuple::Matrix<short>;
10964  }
10965  static void *newArray_NTuplecLcLMatrixlEshortgR(Long_t nElements, void *p) {
10966  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<short>[nElements] : new ::NTuple::Matrix<short>[nElements];
10967  }
10968  // Wrapper around operator delete
10969  static void delete_NTuplecLcLMatrixlEshortgR(void *p) {
10970  delete ((::NTuple::Matrix<short>*)p);
10971  }
10972  static void deleteArray_NTuplecLcLMatrixlEshortgR(void *p) {
10973  delete [] ((::NTuple::Matrix<short>*)p);
10974  }
10975  static void destruct_NTuplecLcLMatrixlEshortgR(void *p) {
10976  typedef ::NTuple::Matrix<short> current_t;
10977  ((current_t*)p)->~current_t();
10978  }
10979 } // end of namespace ROOT for class ::NTuple::Matrix<short>
10980 
10981 namespace ROOT {
10982  // Wrappers around operator new
10983  static void *new_NTuplecLcLMatrixlEunsignedsPshortgR(void *p) {
10984  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned short> : new ::NTuple::Matrix<unsigned short>;
10985  }
10986  static void *newArray_NTuplecLcLMatrixlEunsignedsPshortgR(Long_t nElements, void *p) {
10987  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned short>[nElements] : new ::NTuple::Matrix<unsigned short>[nElements];
10988  }
10989  // Wrapper around operator delete
10990  static void delete_NTuplecLcLMatrixlEunsignedsPshortgR(void *p) {
10991  delete ((::NTuple::Matrix<unsigned short>*)p);
10992  }
10993  static void deleteArray_NTuplecLcLMatrixlEunsignedsPshortgR(void *p) {
10994  delete [] ((::NTuple::Matrix<unsigned short>*)p);
10995  }
10996  static void destruct_NTuplecLcLMatrixlEunsignedsPshortgR(void *p) {
10997  typedef ::NTuple::Matrix<unsigned short> current_t;
10998  ((current_t*)p)->~current_t();
10999  }
11000 } // end of namespace ROOT for class ::NTuple::Matrix<unsigned short>
11001 
11002 namespace ROOT {
11003  // Wrappers around operator new
11004  static void *new_NTuplecLcLMatrixlElonggR(void *p) {
11005  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<long> : new ::NTuple::Matrix<long>;
11006  }
11007  static void *newArray_NTuplecLcLMatrixlElonggR(Long_t nElements, void *p) {
11008  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<long>[nElements] : new ::NTuple::Matrix<long>[nElements];
11009  }
11010  // Wrapper around operator delete
11011  static void delete_NTuplecLcLMatrixlElonggR(void *p) {
11012  delete ((::NTuple::Matrix<long>*)p);
11013  }
11014  static void deleteArray_NTuplecLcLMatrixlElonggR(void *p) {
11015  delete [] ((::NTuple::Matrix<long>*)p);
11016  }
11017  static void destruct_NTuplecLcLMatrixlElonggR(void *p) {
11018  typedef ::NTuple::Matrix<long> current_t;
11019  ((current_t*)p)->~current_t();
11020  }
11021 } // end of namespace ROOT for class ::NTuple::Matrix<long>
11022 
11023 namespace ROOT {
11024  // Wrappers around operator new
11025  static void *new_NTuplecLcLMatrixlEunsignedsPlonggR(void *p) {
11026  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned long> : new ::NTuple::Matrix<unsigned long>;
11027  }
11028  static void *newArray_NTuplecLcLMatrixlEunsignedsPlonggR(Long_t nElements, void *p) {
11029  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned long>[nElements] : new ::NTuple::Matrix<unsigned long>[nElements];
11030  }
11031  // Wrapper around operator delete
11032  static void delete_NTuplecLcLMatrixlEunsignedsPlonggR(void *p) {
11033  delete ((::NTuple::Matrix<unsigned long>*)p);
11034  }
11035  static void deleteArray_NTuplecLcLMatrixlEunsignedsPlonggR(void *p) {
11036  delete [] ((::NTuple::Matrix<unsigned long>*)p);
11037  }
11038  static void destruct_NTuplecLcLMatrixlEunsignedsPlonggR(void *p) {
11039  typedef ::NTuple::Matrix<unsigned long> current_t;
11040  ((current_t*)p)->~current_t();
11041  }
11042 } // end of namespace ROOT for class ::NTuple::Matrix<unsigned long>
11043 
11044 namespace ROOT {
11045  // Wrappers around operator new
11046  static void *new_NTuplecLcLMatrixlEintgR(void *p) {
11047  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<int> : new ::NTuple::Matrix<int>;
11048  }
11049  static void *newArray_NTuplecLcLMatrixlEintgR(Long_t nElements, void *p) {
11050  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<int>[nElements] : new ::NTuple::Matrix<int>[nElements];
11051  }
11052  // Wrapper around operator delete
11053  static void delete_NTuplecLcLMatrixlEintgR(void *p) {
11054  delete ((::NTuple::Matrix<int>*)p);
11055  }
11056  static void deleteArray_NTuplecLcLMatrixlEintgR(void *p) {
11057  delete [] ((::NTuple::Matrix<int>*)p);
11058  }
11059  static void destruct_NTuplecLcLMatrixlEintgR(void *p) {
11060  typedef ::NTuple::Matrix<int> current_t;
11061  ((current_t*)p)->~current_t();
11062  }
11063 } // end of namespace ROOT for class ::NTuple::Matrix<int>
11064 
11065 namespace ROOT {
11066  // Wrappers around operator new
11067  static void *new_NTuplecLcLMatrixlEunsignedsPintgR(void *p) {
11068  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned int> : new ::NTuple::Matrix<unsigned int>;
11069  }
11070  static void *newArray_NTuplecLcLMatrixlEunsignedsPintgR(Long_t nElements, void *p) {
11071  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned int>[nElements] : new ::NTuple::Matrix<unsigned int>[nElements];
11072  }
11073  // Wrapper around operator delete
11074  static void delete_NTuplecLcLMatrixlEunsignedsPintgR(void *p) {
11075  delete ((::NTuple::Matrix<unsigned int>*)p);
11076  }
11077  static void deleteArray_NTuplecLcLMatrixlEunsignedsPintgR(void *p) {
11078  delete [] ((::NTuple::Matrix<unsigned int>*)p);
11079  }
11080  static void destruct_NTuplecLcLMatrixlEunsignedsPintgR(void *p) {
11081  typedef ::NTuple::Matrix<unsigned int> current_t;
11082  ((current_t*)p)->~current_t();
11083  }
11084 } // end of namespace ROOT for class ::NTuple::Matrix<unsigned int>
11085 
11086 namespace ROOT {
11087  // Wrappers around operator new
11088  static void *new_NTuplecLcLMatrixlEfloatgR(void *p) {
11089  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<float> : new ::NTuple::Matrix<float>;
11090  }
11091  static void *newArray_NTuplecLcLMatrixlEfloatgR(Long_t nElements, void *p) {
11092  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<float>[nElements] : new ::NTuple::Matrix<float>[nElements];
11093  }
11094  // Wrapper around operator delete
11095  static void delete_NTuplecLcLMatrixlEfloatgR(void *p) {
11096  delete ((::NTuple::Matrix<float>*)p);
11097  }
11098  static void deleteArray_NTuplecLcLMatrixlEfloatgR(void *p) {
11099  delete [] ((::NTuple::Matrix<float>*)p);
11100  }
11101  static void destruct_NTuplecLcLMatrixlEfloatgR(void *p) {
11102  typedef ::NTuple::Matrix<float> current_t;
11103  ((current_t*)p)->~current_t();
11104  }
11105 } // end of namespace ROOT for class ::NTuple::Matrix<float>
11106 
11107 namespace ROOT {
11108  // Wrappers around operator new
11109  static void *new_NTuplecLcLMatrixlEdoublegR(void *p) {
11110  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<double> : new ::NTuple::Matrix<double>;
11111  }
11112  static void *newArray_NTuplecLcLMatrixlEdoublegR(Long_t nElements, void *p) {
11113  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<double>[nElements] : new ::NTuple::Matrix<double>[nElements];
11114  }
11115  // Wrapper around operator delete
11116  static void delete_NTuplecLcLMatrixlEdoublegR(void *p) {
11117  delete ((::NTuple::Matrix<double>*)p);
11118  }
11119  static void deleteArray_NTuplecLcLMatrixlEdoublegR(void *p) {
11120  delete [] ((::NTuple::Matrix<double>*)p);
11121  }
11122  static void destruct_NTuplecLcLMatrixlEdoublegR(void *p) {
11123  typedef ::NTuple::Matrix<double> current_t;
11124  ((current_t*)p)->~current_t();
11125  }
11126 } // end of namespace ROOT for class ::NTuple::Matrix<double>
11127 
11128 namespace ROOT {
11129  // Wrappers around operator new
11130  static void *new_NTuplecLcLItemlEboolgR(void *p) {
11131  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<bool> : new ::NTuple::Item<bool>;
11132  }
11133  static void *newArray_NTuplecLcLItemlEboolgR(Long_t nElements, void *p) {
11134  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<bool>[nElements] : new ::NTuple::Item<bool>[nElements];
11135  }
11136  // Wrapper around operator delete
11137  static void delete_NTuplecLcLItemlEboolgR(void *p) {
11138  delete ((::NTuple::Item<bool>*)p);
11139  }
11140  static void deleteArray_NTuplecLcLItemlEboolgR(void *p) {
11141  delete [] ((::NTuple::Item<bool>*)p);
11142  }
11143  static void destruct_NTuplecLcLItemlEboolgR(void *p) {
11144  typedef ::NTuple::Item<bool> current_t;
11145  ((current_t*)p)->~current_t();
11146  }
11147 } // end of namespace ROOT for class ::NTuple::Item<bool>
11148 
11149 namespace ROOT {
11150  // Wrappers around operator new
11151  static void *new_NTuplecLcLDirectory(void *p) {
11152  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Directory : new ::NTuple::Directory;
11153  }
11154  static void *newArray_NTuplecLcLDirectory(Long_t nElements, void *p) {
11155  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Directory[nElements] : new ::NTuple::Directory[nElements];
11156  }
11157  // Wrapper around operator delete
11158  static void delete_NTuplecLcLDirectory(void *p) {
11159  delete ((::NTuple::Directory*)p);
11160  }
11161  static void deleteArray_NTuplecLcLDirectory(void *p) {
11162  delete [] ((::NTuple::Directory*)p);
11163  }
11164  static void destruct_NTuplecLcLDirectory(void *p) {
11165  typedef ::NTuple::Directory current_t;
11166  ((current_t*)p)->~current_t();
11167  }
11168 } // end of namespace ROOT for class ::NTuple::Directory
11169 
11170 namespace ROOT {
11171  // Wrappers around operator new
11172  static void *new_NTuplecLcLFile(void *p) {
11173  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::File : new ::NTuple::File;
11174  }
11175  static void *newArray_NTuplecLcLFile(Long_t nElements, void *p) {
11176  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::File[nElements] : new ::NTuple::File[nElements];
11177  }
11178  // Wrapper around operator delete
11179  static void delete_NTuplecLcLFile(void *p) {
11180  delete ((::NTuple::File*)p);
11181  }
11182  static void deleteArray_NTuplecLcLFile(void *p) {
11183  delete [] ((::NTuple::File*)p);
11184  }
11185  static void destruct_NTuplecLcLFile(void *p) {
11186  typedef ::NTuple::File current_t;
11187  ((current_t*)p)->~current_t();
11188  }
11189 } // end of namespace ROOT for class ::NTuple::File
11190 
11191 namespace ROOT {
11192  // Wrapper around operator delete
11193  static void delete_NTuplecLcLArraylEIOpaqueAddressmUgR(void *p) {
11194  delete ((::NTuple::Array<IOpaqueAddress*>*)p);
11195  }
11196  static void deleteArray_NTuplecLcLArraylEIOpaqueAddressmUgR(void *p) {
11197  delete [] ((::NTuple::Array<IOpaqueAddress*>*)p);
11198  }
11199  static void destruct_NTuplecLcLArraylEIOpaqueAddressmUgR(void *p) {
11200  typedef ::NTuple::Array<IOpaqueAddress*> current_t;
11201  ((current_t*)p)->~current_t();
11202  }
11203 } // end of namespace ROOT for class ::NTuple::Array<IOpaqueAddress*>
11204 
11205 namespace ROOT {
11206  // Wrapper around operator delete
11207  static void delete_NTuplecLcLMatrixlEIOpaqueAddressmUgR(void *p) {
11208  delete ((::NTuple::Matrix<IOpaqueAddress*>*)p);
11209  }
11210  static void deleteArray_NTuplecLcLMatrixlEIOpaqueAddressmUgR(void *p) {
11211  delete [] ((::NTuple::Matrix<IOpaqueAddress*>*)p);
11212  }
11213  static void destruct_NTuplecLcLMatrixlEIOpaqueAddressmUgR(void *p) {
11214  typedef ::NTuple::Matrix<IOpaqueAddress*> current_t;
11215  ((current_t*)p)->~current_t();
11216  }
11217 } // end of namespace ROOT for class ::NTuple::Matrix<IOpaqueAddress*>
11218 
11219 namespace ROOT {
11220  // Wrapper around operator delete
11221  static void delete_NTuplecLcLColumnWiseTuple(void *p) {
11222  delete ((::NTuple::ColumnWiseTuple*)p);
11223  }
11224  static void deleteArray_NTuplecLcLColumnWiseTuple(void *p) {
11225  delete [] ((::NTuple::ColumnWiseTuple*)p);
11226  }
11227  static void destruct_NTuplecLcLColumnWiseTuple(void *p) {
11228  typedef ::NTuple::ColumnWiseTuple current_t;
11229  ((current_t*)p)->~current_t();
11230  }
11231 } // end of namespace ROOT for class ::NTuple::ColumnWiseTuple
11232 
11233 namespace ROOT {
11234  // Wrapper around operator delete
11235  static void delete_NTuplecLcLRowWiseTuple(void *p) {
11236  delete ((::NTuple::RowWiseTuple*)p);
11237  }
11238  static void deleteArray_NTuplecLcLRowWiseTuple(void *p) {
11239  delete [] ((::NTuple::RowWiseTuple*)p);
11240  }
11241  static void destruct_NTuplecLcLRowWiseTuple(void *p) {
11242  typedef ::NTuple::RowWiseTuple current_t;
11243  ((current_t*)p)->~current_t();
11244  }
11245 } // end of namespace ROOT for class ::NTuple::RowWiseTuple
11246 
11247 namespace ROOT {
11248  // Wrapper around operator delete
11249  static void delete_IRegistry(void *p) {
11250  delete ((::IRegistry*)p);
11251  }
11252  static void deleteArray_IRegistry(void *p) {
11253  delete [] ((::IRegistry*)p);
11254  }
11255  static void destruct_IRegistry(void *p) {
11256  typedef ::IRegistry current_t;
11257  ((current_t*)p)->~current_t();
11258  }
11259 } // end of namespace ROOT for class ::IRegistry
11260 
11261 namespace ROOT {
11262  // Wrapper around operator delete
11263  static void delete_RndmcLcLGauss(void *p) {
11264  delete ((::Rndm::Gauss*)p);
11265  }
11266  static void deleteArray_RndmcLcLGauss(void *p) {
11267  delete [] ((::Rndm::Gauss*)p);
11268  }
11269  static void destruct_RndmcLcLGauss(void *p) {
11270  typedef ::Rndm::Gauss current_t;
11271  ((current_t*)p)->~current_t();
11272  }
11273 } // end of namespace ROOT for class ::Rndm::Gauss
11274 
11275 namespace ROOT {
11276  // Wrapper around operator delete
11277  static void delete_RndmcLcLExponential(void *p) {
11278  delete ((::Rndm::Exponential*)p);
11279  }
11280  static void deleteArray_RndmcLcLExponential(void *p) {
11281  delete [] ((::Rndm::Exponential*)p);
11282  }
11283  static void destruct_RndmcLcLExponential(void *p) {
11284  typedef ::Rndm::Exponential current_t;
11285  ((current_t*)p)->~current_t();
11286  }
11287 } // end of namespace ROOT for class ::Rndm::Exponential
11288 
11289 namespace ROOT {
11290  // Wrapper around operator delete
11291  static void delete_RndmcLcLChi2(void *p) {
11292  delete ((::Rndm::Chi2*)p);
11293  }
11294  static void deleteArray_RndmcLcLChi2(void *p) {
11295  delete [] ((::Rndm::Chi2*)p);
11296  }
11297  static void destruct_RndmcLcLChi2(void *p) {
11298  typedef ::Rndm::Chi2 current_t;
11299  ((current_t*)p)->~current_t();
11300  }
11301 } // end of namespace ROOT for class ::Rndm::Chi2
11302 
11303 namespace ROOT {
11304  // Wrapper around operator delete
11305  static void delete_RndmcLcLBreitWigner(void *p) {
11306  delete ((::Rndm::BreitWigner*)p);
11307  }
11308  static void deleteArray_RndmcLcLBreitWigner(void *p) {
11309  delete [] ((::Rndm::BreitWigner*)p);
11310  }
11311  static void destruct_RndmcLcLBreitWigner(void *p) {
11312  typedef ::Rndm::BreitWigner current_t;
11313  ((current_t*)p)->~current_t();
11314  }
11315 } // end of namespace ROOT for class ::Rndm::BreitWigner
11316 
11317 namespace ROOT {
11318  // Wrapper around operator delete
11319  static void delete_RndmcLcLLandau(void *p) {
11320  delete ((::Rndm::Landau*)p);
11321  }
11322  static void deleteArray_RndmcLcLLandau(void *p) {
11323  delete [] ((::Rndm::Landau*)p);
11324  }
11325  static void destruct_RndmcLcLLandau(void *p) {
11326  typedef ::Rndm::Landau current_t;
11327  ((current_t*)p)->~current_t();
11328  }
11329 } // end of namespace ROOT for class ::Rndm::Landau
11330 
11331 namespace ROOT {
11332  // Wrapper around operator delete
11333  static void delete_RndmcLcLBreitWignerCutOff(void *p) {
11334  delete ((::Rndm::BreitWignerCutOff*)p);
11335  }
11336  static void deleteArray_RndmcLcLBreitWignerCutOff(void *p) {
11337  delete [] ((::Rndm::BreitWignerCutOff*)p);
11338  }
11339  static void destruct_RndmcLcLBreitWignerCutOff(void *p) {
11340  typedef ::Rndm::BreitWignerCutOff current_t;
11341  ((current_t*)p)->~current_t();
11342  }
11343 } // end of namespace ROOT for class ::Rndm::BreitWignerCutOff
11344 
11345 namespace ROOT {
11346  // Wrapper around operator delete
11347  static void delete_RndmcLcLStudentT(void *p) {
11348  delete ((::Rndm::StudentT*)p);
11349  }
11350  static void deleteArray_RndmcLcLStudentT(void *p) {
11351  delete [] ((::Rndm::StudentT*)p);
11352  }
11353  static void destruct_RndmcLcLStudentT(void *p) {
11354  typedef ::Rndm::StudentT current_t;
11355  ((current_t*)p)->~current_t();
11356  }
11357 } // end of namespace ROOT for class ::Rndm::StudentT
11358 
11359 namespace ROOT {
11360  // Wrapper around operator delete
11361  static void delete_RndmcLcLGamma(void *p) {
11362  delete ((::Rndm::Gamma*)p);
11363  }
11364  static void deleteArray_RndmcLcLGamma(void *p) {
11365  delete [] ((::Rndm::Gamma*)p);
11366  }
11367  static void destruct_RndmcLcLGamma(void *p) {
11368  typedef ::Rndm::Gamma current_t;
11369  ((current_t*)p)->~current_t();
11370  }
11371 } // end of namespace ROOT for class ::Rndm::Gamma
11372 
11373 namespace ROOT {
11374  // Wrapper around operator delete
11375  static void delete_RndmcLcLPoisson(void *p) {
11376  delete ((::Rndm::Poisson*)p);
11377  }
11378  static void deleteArray_RndmcLcLPoisson(void *p) {
11379  delete [] ((::Rndm::Poisson*)p);
11380  }
11381  static void destruct_RndmcLcLPoisson(void *p) {
11382  typedef ::Rndm::Poisson current_t;
11383  ((current_t*)p)->~current_t();
11384  }
11385 } // end of namespace ROOT for class ::Rndm::Poisson
11386 
11387 namespace ROOT {
11388  // Wrapper around operator delete
11389  static void delete_RndmcLcLBinomial(void *p) {
11390  delete ((::Rndm::Binomial*)p);
11391  }
11392  static void deleteArray_RndmcLcLBinomial(void *p) {
11393  delete [] ((::Rndm::Binomial*)p);
11394  }
11395  static void destruct_RndmcLcLBinomial(void *p) {
11396  typedef ::Rndm::Binomial current_t;
11397  ((current_t*)p)->~current_t();
11398  }
11399 } // end of namespace ROOT for class ::Rndm::Binomial
11400 
11401 namespace ROOT {
11402  // Wrapper around operator delete
11403  static void delete_RndmcLcLFlat(void *p) {
11404  delete ((::Rndm::Flat*)p);
11405  }
11406  static void deleteArray_RndmcLcLFlat(void *p) {
11407  delete [] ((::Rndm::Flat*)p);
11408  }
11409  static void destruct_RndmcLcLFlat(void *p) {
11410  typedef ::Rndm::Flat current_t;
11411  ((current_t*)p)->~current_t();
11412  }
11413 } // end of namespace ROOT for class ::Rndm::Flat
11414 
11415 namespace ROOT {
11416  // Wrappers around operator new
11417  static void *new_RndmcLcLBit(void *p) {
11418  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Rndm::Bit : new ::Rndm::Bit;
11419  }
11420  static void *newArray_RndmcLcLBit(Long_t nElements, void *p) {
11421  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Rndm::Bit[nElements] : new ::Rndm::Bit[nElements];
11422  }
11423  // Wrapper around operator delete
11424  static void delete_RndmcLcLBit(void *p) {
11425  delete ((::Rndm::Bit*)p);
11426  }
11427  static void deleteArray_RndmcLcLBit(void *p) {
11428  delete [] ((::Rndm::Bit*)p);
11429  }
11430  static void destruct_RndmcLcLBit(void *p) {
11431  typedef ::Rndm::Bit current_t;
11432  ((current_t*)p)->~current_t();
11433  }
11434 } // end of namespace ROOT for class ::Rndm::Bit
11435 
11436 namespace ROOT {
11437  // Wrapper around operator delete
11438  static void delete_RndmcLcLDefinedPdf(void *p) {
11439  delete ((::Rndm::DefinedPdf*)p);
11440  }
11441  static void deleteArray_RndmcLcLDefinedPdf(void *p) {
11442  delete [] ((::Rndm::DefinedPdf*)p);
11443  }
11444  static void destruct_RndmcLcLDefinedPdf(void *p) {
11445  typedef ::Rndm::DefinedPdf current_t;
11446  ((current_t*)p)->~current_t();
11447  }
11448 } // end of namespace ROOT for class ::Rndm::DefinedPdf
11449 
11450 namespace ROOT {
11451  // Wrapper around operator delete
11452  static void delete_RndmcLcLGaussianTail(void *p) {
11453  delete ((::Rndm::GaussianTail*)p);
11454  }
11455  static void deleteArray_RndmcLcLGaussianTail(void *p) {
11456  delete [] ((::Rndm::GaussianTail*)p);
11457  }
11458  static void destruct_RndmcLcLGaussianTail(void *p) {
11459  typedef ::Rndm::GaussianTail current_t;
11460  ((current_t*)p)->~current_t();
11461  }
11462 } // end of namespace ROOT for class ::Rndm::GaussianTail
11463 
11464 namespace ROOT {
11465  // Wrappers around operator new
11466  static void *new_RndmcLcLNumbers(void *p) {
11467  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Rndm::Numbers : new ::Rndm::Numbers;
11468  }
11469  static void *newArray_RndmcLcLNumbers(Long_t nElements, void *p) {
11470  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Rndm::Numbers[nElements] : new ::Rndm::Numbers[nElements];
11471  }
11472  // Wrapper around operator delete
11473  static void delete_RndmcLcLNumbers(void *p) {
11474  delete ((::Rndm::Numbers*)p);
11475  }
11476  static void deleteArray_RndmcLcLNumbers(void *p) {
11477  delete [] ((::Rndm::Numbers*)p);
11478  }
11479  static void destruct_RndmcLcLNumbers(void *p) {
11480  typedef ::Rndm::Numbers current_t;
11481  ((current_t*)p)->~current_t();
11482  }
11483 } // end of namespace ROOT for class ::Rndm::Numbers
11484 
11485 namespace ROOT {
11486  // Wrappers around operator new
11487  static void *new_SmartRefVectorlEDataObjectgR(void *p) {
11488  return p ? new(p) ::SmartRefVector<DataObject> : new ::SmartRefVector<DataObject>;
11489  }
11490  static void *newArray_SmartRefVectorlEDataObjectgR(Long_t nElements, void *p) {
11491  return p ? new(p) ::SmartRefVector<DataObject>[nElements] : new ::SmartRefVector<DataObject>[nElements];
11492  }
11493  // Wrapper around operator delete
11494  static void delete_SmartRefVectorlEDataObjectgR(void *p) {
11495  delete ((::SmartRefVector<DataObject>*)p);
11496  }
11497  static void deleteArray_SmartRefVectorlEDataObjectgR(void *p) {
11498  delete [] ((::SmartRefVector<DataObject>*)p);
11499  }
11500  static void destruct_SmartRefVectorlEDataObjectgR(void *p) {
11501  typedef ::SmartRefVector<DataObject> current_t;
11502  ((current_t*)p)->~current_t();
11503  }
11504 } // end of namespace ROOT for class ::SmartRefVector<DataObject>
11505 
11506 namespace ROOT {
11507  // Wrappers around operator new
11508  static void *new_SmartRefVectorlEContainedObjectgR(void *p) {
11509  return p ? new(p) ::SmartRefVector<ContainedObject> : new ::SmartRefVector<ContainedObject>;
11510  }
11511  static void *newArray_SmartRefVectorlEContainedObjectgR(Long_t nElements, void *p) {
11512  return p ? new(p) ::SmartRefVector<ContainedObject>[nElements] : new ::SmartRefVector<ContainedObject>[nElements];
11513  }
11514  // Wrapper around operator delete
11515  static void delete_SmartRefVectorlEContainedObjectgR(void *p) {
11516  delete ((::SmartRefVector<ContainedObject>*)p);
11517  }
11518  static void deleteArray_SmartRefVectorlEContainedObjectgR(void *p) {
11519  delete [] ((::SmartRefVector<ContainedObject>*)p);
11520  }
11521  static void destruct_SmartRefVectorlEContainedObjectgR(void *p) {
11522  typedef ::SmartRefVector<ContainedObject> current_t;
11523  ((current_t*)p)->~current_t();
11524  }
11525 } // end of namespace ROOT for class ::SmartRefVector<ContainedObject>
11526 
11527 namespace ROOT {
11528  // Wrappers around operator new
11529  static void *new_SmartRefVectorlEObjectContainerBasegR(void *p) {
11530  return p ? new(p) ::SmartRefVector<ObjectContainerBase> : new ::SmartRefVector<ObjectContainerBase>;
11531  }
11532  static void *newArray_SmartRefVectorlEObjectContainerBasegR(Long_t nElements, void *p) {
11533  return p ? new(p) ::SmartRefVector<ObjectContainerBase>[nElements] : new ::SmartRefVector<ObjectContainerBase>[nElements];
11534  }
11535  // Wrapper around operator delete
11536  static void delete_SmartRefVectorlEObjectContainerBasegR(void *p) {
11537  delete ((::SmartRefVector<ObjectContainerBase>*)p);
11538  }
11539  static void deleteArray_SmartRefVectorlEObjectContainerBasegR(void *p) {
11540  delete [] ((::SmartRefVector<ObjectContainerBase>*)p);
11541  }
11542  static void destruct_SmartRefVectorlEObjectContainerBasegR(void *p) {
11543  typedef ::SmartRefVector<ObjectContainerBase> current_t;
11544  ((current_t*)p)->~current_t();
11545  }
11546 } // end of namespace ROOT for class ::SmartRefVector<ObjectContainerBase>
11547 
11548 namespace ROOT {
11549  // Wrappers around operator new
11550  static void *new_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p) {
11551  return p ? new(p) ::SmartRefVector<KeyedObject<int> > : new ::SmartRefVector<KeyedObject<int> >;
11552  }
11553  static void *newArray_SmartRefVectorlEKeyedObjectlEintgRsPgR(Long_t nElements, void *p) {
11554  return p ? new(p) ::SmartRefVector<KeyedObject<int> >[nElements] : new ::SmartRefVector<KeyedObject<int> >[nElements];
11555  }
11556  // Wrapper around operator delete
11557  static void delete_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p) {
11558  delete ((::SmartRefVector<KeyedObject<int> >*)p);
11559  }
11560  static void deleteArray_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p) {
11561  delete [] ((::SmartRefVector<KeyedObject<int> >*)p);
11562  }
11563  static void destruct_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p) {
11564  typedef ::SmartRefVector<KeyedObject<int> > current_t;
11565  ((current_t*)p)->~current_t();
11566  }
11567 } // end of namespace ROOT for class ::SmartRefVector<KeyedObject<int> >
11568 
11569 namespace ROOT {
11570  // Wrappers around operator new
11571  static void *new_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
11572  return p ? new(p) ::SmartRefVector<KeyedObject<unsigned int> > : new ::SmartRefVector<KeyedObject<unsigned int> >;
11573  }
11574  static void *newArray_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(Long_t nElements, void *p) {
11575  return p ? new(p) ::SmartRefVector<KeyedObject<unsigned int> >[nElements] : new ::SmartRefVector<KeyedObject<unsigned int> >[nElements];
11576  }
11577  // Wrapper around operator delete
11578  static void delete_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
11579  delete ((::SmartRefVector<KeyedObject<unsigned int> >*)p);
11580  }
11581  static void deleteArray_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
11582  delete [] ((::SmartRefVector<KeyedObject<unsigned int> >*)p);
11583  }
11584  static void destruct_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
11585  typedef ::SmartRefVector<KeyedObject<unsigned int> > current_t;
11586  ((current_t*)p)->~current_t();
11587  }
11588 } // end of namespace ROOT for class ::SmartRefVector<KeyedObject<unsigned int> >
11589 
11590 namespace ROOT {
11591  // Wrappers around operator new
11592  static void *new_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p) {
11593  return p ? new(p) ::SmartRefVector<KeyedObject<long> > : new ::SmartRefVector<KeyedObject<long> >;
11594  }
11595  static void *newArray_SmartRefVectorlEKeyedObjectlElonggRsPgR(Long_t nElements, void *p) {
11596  return p ? new(p) ::SmartRefVector<KeyedObject<long> >[nElements] : new ::SmartRefVector<KeyedObject<long> >[nElements];
11597  }
11598  // Wrapper around operator delete
11599  static void delete_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p) {
11600  delete ((::SmartRefVector<KeyedObject<long> >*)p);
11601  }
11602  static void deleteArray_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p) {
11603  delete [] ((::SmartRefVector<KeyedObject<long> >*)p);
11604  }
11605  static void destruct_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p) {
11606  typedef ::SmartRefVector<KeyedObject<long> > current_t;
11607  ((current_t*)p)->~current_t();
11608  }
11609 } // end of namespace ROOT for class ::SmartRefVector<KeyedObject<long> >
11610 
11611 namespace ROOT {
11612  // Wrappers around operator new
11613  static void *new_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
11614  return p ? new(p) ::SmartRefVector<KeyedObject<unsigned long> > : new ::SmartRefVector<KeyedObject<unsigned long> >;
11615  }
11616  static void *newArray_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(Long_t nElements, void *p) {
11617  return p ? new(p) ::SmartRefVector<KeyedObject<unsigned long> >[nElements] : new ::SmartRefVector<KeyedObject<unsigned long> >[nElements];
11618  }
11619  // Wrapper around operator delete
11620  static void delete_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
11621  delete ((::SmartRefVector<KeyedObject<unsigned long> >*)p);
11622  }
11623  static void deleteArray_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
11624  delete [] ((::SmartRefVector<KeyedObject<unsigned long> >*)p);
11625  }
11626  static void destruct_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
11627  typedef ::SmartRefVector<KeyedObject<unsigned long> > current_t;
11628  ((current_t*)p)->~current_t();
11629  }
11630 } // end of namespace ROOT for class ::SmartRefVector<KeyedObject<unsigned long> >
11631 
11632 namespace ROOT {
11633  // Wrappers around operator new
11634  static void *new_GaudicLcLTime(void *p) {
11635  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Time : new ::Gaudi::Time;
11636  }
11637  static void *newArray_GaudicLcLTime(Long_t nElements, void *p) {
11638  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Time[nElements] : new ::Gaudi::Time[nElements];
11639  }
11640  // Wrapper around operator delete
11641  static void delete_GaudicLcLTime(void *p) {
11642  delete ((::Gaudi::Time*)p);
11643  }
11644  static void deleteArray_GaudicLcLTime(void *p) {
11645  delete [] ((::Gaudi::Time*)p);
11646  }
11647  static void destruct_GaudicLcLTime(void *p) {
11648  typedef ::Gaudi::Time current_t;
11649  ((current_t*)p)->~current_t();
11650  }
11651 } // end of namespace ROOT for class ::Gaudi::Time
11652 
11653 namespace ROOT {
11654  // Wrapper around operator delete
11655  static void delete_DataObjectHandleBase(void *p) {
11656  delete ((::DataObjectHandleBase*)p);
11657  }
11658  static void deleteArray_DataObjectHandleBase(void *p) {
11659  delete [] ((::DataObjectHandleBase*)p);
11660  }
11661  static void destruct_DataObjectHandleBase(void *p) {
11662  typedef ::DataObjectHandleBase current_t;
11663  ((current_t*)p)->~current_t();
11664  }
11665 } // end of namespace ROOT for class ::DataObjectHandleBase
11666 
11667 namespace ROOT {
11668  // Wrapper around operator delete
11669  static void delete_IAddressCreator(void *p) {
11670  delete ((::IAddressCreator*)p);
11671  }
11672  static void deleteArray_IAddressCreator(void *p) {
11673  delete [] ((::IAddressCreator*)p);
11674  }
11675  static void destruct_IAddressCreator(void *p) {
11676  typedef ::IAddressCreator current_t;
11677  ((current_t*)p)->~current_t();
11678  }
11679 } // end of namespace ROOT for class ::IAddressCreator
11680 
11681 namespace ROOT {
11682  // Wrapper around operator delete
11683  static void delete_IAlgManager(void *p) {
11684  delete ((::IAlgManager*)p);
11685  }
11686  static void deleteArray_IAlgManager(void *p) {
11687  delete [] ((::IAlgManager*)p);
11688  }
11689  static void destruct_IAlgManager(void *p) {
11690  typedef ::IAlgManager current_t;
11691  ((current_t*)p)->~current_t();
11692  }
11693 } // end of namespace ROOT for class ::IAlgManager
11694 
11695 namespace ROOT {
11696  // Wrapper around operator delete
11697  static void delete_IAppMgrUI(void *p) {
11698  delete ((::IAppMgrUI*)p);
11699  }
11700  static void deleteArray_IAppMgrUI(void *p) {
11701  delete [] ((::IAppMgrUI*)p);
11702  }
11703  static void destruct_IAppMgrUI(void *p) {
11704  typedef ::IAppMgrUI current_t;
11705  ((current_t*)p)->~current_t();
11706  }
11707 } // end of namespace ROOT for class ::IAppMgrUI
11708 
11709 namespace ROOT {
11710  // Wrapper around operator delete
11711  static void delete_IClassInfo(void *p) {
11712  delete ((::IClassInfo*)p);
11713  }
11714  static void deleteArray_IClassInfo(void *p) {
11715  delete [] ((::IClassInfo*)p);
11716  }
11717  static void destruct_IClassInfo(void *p) {
11718  typedef ::IClassInfo current_t;
11719  ((current_t*)p)->~current_t();
11720  }
11721 } // end of namespace ROOT for class ::IClassInfo
11722 
11723 namespace ROOT {
11724  // Wrapper around operator delete
11725  static void delete_IClassManager(void *p) {
11726  delete ((::IClassManager*)p);
11727  }
11728  static void deleteArray_IClassManager(void *p) {
11729  delete [] ((::IClassManager*)p);
11730  }
11731  static void destruct_IClassManager(void *p) {
11732  typedef ::IClassManager current_t;
11733  ((current_t*)p)->~current_t();
11734  }
11735 } // end of namespace ROOT for class ::IClassManager
11736 
11737 namespace ROOT {
11738  // Wrapper around operator delete
11739  static void delete_ICounterSummarySvc(void *p) {
11740  delete ((::ICounterSummarySvc*)p);
11741  }
11742  static void deleteArray_ICounterSummarySvc(void *p) {
11743  delete [] ((::ICounterSummarySvc*)p);
11744  }
11745  static void destruct_ICounterSummarySvc(void *p) {
11746  typedef ::ICounterSummarySvc current_t;
11747  ((current_t*)p)->~current_t();
11748  }
11749 } // end of namespace ROOT for class ::ICounterSummarySvc
11750 
11751 namespace ROOT {
11752  // Wrapper around operator delete
11753  static void delete_ICounterSvc(void *p) {
11754  delete ((::ICounterSvc*)p);
11755  }
11756  static void deleteArray_ICounterSvc(void *p) {
11757  delete [] ((::ICounterSvc*)p);
11758  }
11759  static void destruct_ICounterSvc(void *p) {
11760  typedef ::ICounterSvc current_t;
11761  ((current_t*)p)->~current_t();
11762  }
11763 } // end of namespace ROOT for class ::ICounterSvc
11764 
11765 namespace ROOT {
11766  // Wrapper around operator delete
11767  static void delete_IDataManagerSvc(void *p) {
11768  delete ((::IDataManagerSvc*)p);
11769  }
11770  static void deleteArray_IDataManagerSvc(void *p) {
11771  delete [] ((::IDataManagerSvc*)p);
11772  }
11773  static void destruct_IDataManagerSvc(void *p) {
11774  typedef ::IDataManagerSvc current_t;
11775  ((current_t*)p)->~current_t();
11776  }
11777 } // end of namespace ROOT for class ::IDataManagerSvc
11778 
11779 namespace ROOT {
11780  // Wrapper around operator delete
11781  static void delete_IDataSourceMgr(void *p) {
11782  delete ((::IDataSourceMgr*)p);
11783  }
11784  static void deleteArray_IDataSourceMgr(void *p) {
11785  delete [] ((::IDataSourceMgr*)p);
11786  }
11787  static void destruct_IDataSourceMgr(void *p) {
11788  typedef ::IDataSourceMgr current_t;
11789  ((current_t*)p)->~current_t();
11790  }
11791 } // end of namespace ROOT for class ::IDataSourceMgr
11792 
11793 namespace ROOT {
11794  // Wrapper around operator delete
11795  static void delete_IDataStoreAgent(void *p) {
11796  delete ((::IDataStoreAgent*)p);
11797  }
11798  static void deleteArray_IDataStoreAgent(void *p) {
11799  delete [] ((::IDataStoreAgent*)p);
11800  }
11801  static void destruct_IDataStoreAgent(void *p) {
11802  typedef ::IDataStoreAgent current_t;
11803  ((current_t*)p)->~current_t();
11804  }
11805 } // end of namespace ROOT for class ::IDataStoreAgent
11806 
11807 namespace ROOT {
11808  // Wrapper around operator delete
11809  static void delete_IDataStoreLeaves(void *p) {
11810  delete ((::IDataStoreLeaves*)p);
11811  }
11812  static void deleteArray_IDataStoreLeaves(void *p) {
11813  delete [] ((::IDataStoreLeaves*)p);
11814  }
11815  static void destruct_IDataStoreLeaves(void *p) {
11816  typedef ::IDataStoreLeaves current_t;
11817  ((current_t*)p)->~current_t();
11818  }
11819 } // end of namespace ROOT for class ::IDataStoreLeaves
11820 
11821 namespace ROOT {
11822  // Wrapper around operator delete
11823  static void delete_IDetDataSvc(void *p) {
11824  delete ((::IDetDataSvc*)p);
11825  }
11826  static void deleteArray_IDetDataSvc(void *p) {
11827  delete [] ((::IDetDataSvc*)p);
11828  }
11829  static void destruct_IDetDataSvc(void *p) {
11830  typedef ::IDetDataSvc current_t;
11831  ((current_t*)p)->~current_t();
11832  }
11833 } // end of namespace ROOT for class ::IDetDataSvc
11834 
11835 namespace ROOT {
11836  // Wrapper around operator delete
11837  static void delete_IEventProcessor(void *p) {
11838  delete ((::IEventProcessor*)p);
11839  }
11840  static void deleteArray_IEventProcessor(void *p) {
11841  delete [] ((::IEventProcessor*)p);
11842  }
11843  static void destruct_IEventProcessor(void *p) {
11844  typedef ::IEventProcessor current_t;
11845  ((current_t*)p)->~current_t();
11846  }
11847 } // end of namespace ROOT for class ::IEventProcessor
11848 
11849 namespace ROOT {
11850  // Wrapper around operator delete
11851  static void delete_IEventTimeDecoder(void *p) {
11852  delete ((::IEventTimeDecoder*)p);
11853  }
11854  static void deleteArray_IEventTimeDecoder(void *p) {
11855  delete [] ((::IEventTimeDecoder*)p);
11856  }
11857  static void destruct_IEventTimeDecoder(void *p) {
11858  typedef ::IEventTimeDecoder current_t;
11859  ((current_t*)p)->~current_t();
11860  }
11861 } // end of namespace ROOT for class ::IEventTimeDecoder
11862 
11863 namespace ROOT {
11864  // Wrapper around operator delete
11865  static void delete_IHistorySvc(void *p) {
11866  delete ((::IHistorySvc*)p);
11867  }
11868  static void deleteArray_IHistorySvc(void *p) {
11869  delete [] ((::IHistorySvc*)p);
11870  }
11871  static void destruct_IHistorySvc(void *p) {
11872  typedef ::IHistorySvc current_t;
11873  ((current_t*)p)->~current_t();
11874  }
11875 } // end of namespace ROOT for class ::IHistorySvc
11876 
11877 namespace ROOT {
11878  // Wrapper around operator delete
11879  static void delete_IIncidentListener(void *p) {
11880  delete ((::IIncidentListener*)p);
11881  }
11882  static void deleteArray_IIncidentListener(void *p) {
11883  delete [] ((::IIncidentListener*)p);
11884  }
11885  static void destruct_IIncidentListener(void *p) {
11886  typedef ::IIncidentListener current_t;
11887  ((current_t*)p)->~current_t();
11888  }
11889 } // end of namespace ROOT for class ::IIncidentListener
11890 
11891 namespace ROOT {
11892  // Wrapper around operator delete
11893  static void delete_IInspectable(void *p) {
11894  delete ((::IInspectable*)p);
11895  }
11896  static void deleteArray_IInspectable(void *p) {
11897  delete [] ((::IInspectable*)p);
11898  }
11899  static void destruct_IInspectable(void *p) {
11900  typedef ::IInspectable current_t;
11901  ((current_t*)p)->~current_t();
11902  }
11903 } // end of namespace ROOT for class ::IInspectable
11904 
11905 namespace ROOT {
11906  // Wrapper around operator delete
11907  static void delete_IInspector(void *p) {
11908  delete ((::IInspector*)p);
11909  }
11910  static void deleteArray_IInspector(void *p) {
11911  delete [] ((::IInspector*)p);
11912  }
11913  static void destruct_IInspector(void *p) {
11914  typedef ::IInspector current_t;
11915  ((current_t*)p)->~current_t();
11916  }
11917 } // end of namespace ROOT for class ::IInspector
11918 
11919 namespace ROOT {
11920  // Wrapper around operator delete
11921  static void delete_IMagneticFieldSvc(void *p) {
11922  delete ((::IMagneticFieldSvc*)p);
11923  }
11924  static void deleteArray_IMagneticFieldSvc(void *p) {
11925  delete [] ((::IMagneticFieldSvc*)p);
11926  }
11927  static void destruct_IMagneticFieldSvc(void *p) {
11928  typedef ::IMagneticFieldSvc current_t;
11929  ((current_t*)p)->~current_t();
11930  }
11931 } // end of namespace ROOT for class ::IMagneticFieldSvc
11932 
11933 namespace ROOT {
11934  // Wrapper around operator delete
11935  static void delete_IPartPropSvc(void *p) {
11936  delete ((::IPartPropSvc*)p);
11937  }
11938  static void deleteArray_IPartPropSvc(void *p) {
11939  delete [] ((::IPartPropSvc*)p);
11940  }
11941  static void destruct_IPartPropSvc(void *p) {
11942  typedef ::IPartPropSvc current_t;
11943  ((current_t*)p)->~current_t();
11944  }
11945 } // end of namespace ROOT for class ::IPartPropSvc
11946 
11947 namespace ROOT {
11948  // Wrapper around operator delete
11949  static void delete_IParticlePropertySvc(void *p) {
11950  delete ((::IParticlePropertySvc*)p);
11951  }
11952  static void deleteArray_IParticlePropertySvc(void *p) {
11953  delete [] ((::IParticlePropertySvc*)p);
11954  }
11955  static void destruct_IParticlePropertySvc(void *p) {
11956  typedef ::IParticlePropertySvc current_t;
11957  ((current_t*)p)->~current_t();
11958  }
11959 } // end of namespace ROOT for class ::IParticlePropertySvc
11960 
11961 namespace ROOT {
11962  // Wrapper around operator delete
11963  static void delete_IPartitionControl(void *p) {
11964  delete ((::IPartitionControl*)p);
11965  }
11966  static void deleteArray_IPartitionControl(void *p) {
11967  delete [] ((::IPartitionControl*)p);
11968  }
11969  static void destruct_IPartitionControl(void *p) {
11970  typedef ::IPartitionControl current_t;
11971  ((current_t*)p)->~current_t();
11972  }
11973 } // end of namespace ROOT for class ::IPartitionControl
11974 
11975 namespace ROOT {
11976  // Wrapper around operator delete
11977  static void delete_IPersistencySvc(void *p) {
11978  delete ((::IPersistencySvc*)p);
11979  }
11980  static void deleteArray_IPersistencySvc(void *p) {
11981  delete [] ((::IPersistencySvc*)p);
11982  }
11983  static void destruct_IPersistencySvc(void *p) {
11984  typedef ::IPersistencySvc current_t;
11985  ((current_t*)p)->~current_t();
11986  }
11987 } // end of namespace ROOT for class ::IPersistencySvc
11988 
11989 namespace ROOT {
11990  // Wrapper around operator delete
11991  static void delete_IRndmEngine(void *p) {
11992  delete ((::IRndmEngine*)p);
11993  }
11994  static void deleteArray_IRndmEngine(void *p) {
11995  delete [] ((::IRndmEngine*)p);
11996  }
11997  static void destruct_IRndmEngine(void *p) {
11998  typedef ::IRndmEngine current_t;
11999  ((current_t*)p)->~current_t();
12000  }
12001 } // end of namespace ROOT for class ::IRndmEngine
12002 
12003 namespace ROOT {
12004  // Wrapper around operator delete
12005  static void delete_IRunable(void *p) {
12006  delete ((::IRunable*)p);
12007  }
12008  static void deleteArray_IRunable(void *p) {
12009  delete [] ((::IRunable*)p);
12010  }
12011  static void destruct_IRunable(void *p) {
12012  typedef ::IRunable current_t;
12013  ((current_t*)p)->~current_t();
12014  }
12015 } // end of namespace ROOT for class ::IRunable
12016 
12017 namespace ROOT {
12018  // Wrapper around operator delete
12019  static void delete_ISelectStatement(void *p) {
12020  delete ((::ISelectStatement*)p);
12021  }
12022  static void deleteArray_ISelectStatement(void *p) {
12023  delete [] ((::ISelectStatement*)p);
12024  }
12025  static void destruct_ISelectStatement(void *p) {
12026  typedef ::ISelectStatement current_t;
12027  ((current_t*)p)->~current_t();
12028  }
12029 } // end of namespace ROOT for class ::ISelectStatement
12030 
12031 namespace ROOT {
12032  // Wrapper around operator delete
12033  static void delete_ISerialize(void *p) {
12034  delete ((::ISerialize*)p);
12035  }
12036  static void deleteArray_ISerialize(void *p) {
12037  delete [] ((::ISerialize*)p);
12038  }
12039  static void destruct_ISerialize(void *p) {
12040  typedef ::ISerialize current_t;
12041  ((current_t*)p)->~current_t();
12042  }
12043 } // end of namespace ROOT for class ::ISerialize
12044 
12045 namespace ROOT {
12046  // Wrapper around operator delete
12047  static void delete_IStagerSvc(void *p) {
12048  delete ((::IStagerSvc*)p);
12049  }
12050  static void deleteArray_IStagerSvc(void *p) {
12051  delete [] ((::IStagerSvc*)p);
12052  }
12053  static void destruct_IStagerSvc(void *p) {
12054  typedef ::IStagerSvc current_t;
12055  ((current_t*)p)->~current_t();
12056  }
12057 } // end of namespace ROOT for class ::IStagerSvc
12058 
12059 namespace ROOT {
12060  // Wrapper around operator delete
12061  static void delete_IStatusCodeSvc(void *p) {
12062  delete ((::IStatusCodeSvc*)p);
12063  }
12064  static void deleteArray_IStatusCodeSvc(void *p) {
12065  delete [] ((::IStatusCodeSvc*)p);
12066  }
12067  static void destruct_IStatusCodeSvc(void *p) {
12068  typedef ::IStatusCodeSvc current_t;
12069  ((current_t*)p)->~current_t();
12070  }
12071 } // end of namespace ROOT for class ::IStatusCodeSvc
12072 
12073 namespace ROOT {
12074  // Wrapper around operator delete
12075  static void delete_ITHistSvc(void *p) {
12076  delete ((::ITHistSvc*)p);
12077  }
12078  static void deleteArray_ITHistSvc(void *p) {
12079  delete [] ((::ITHistSvc*)p);
12080  }
12081  static void destruct_ITHistSvc(void *p) {
12082  typedef ::ITHistSvc current_t;
12083  ((current_t*)p)->~current_t();
12084  }
12085 } // end of namespace ROOT for class ::ITHistSvc
12086 
12087 namespace ROOT {
12088  // Wrapper around operator delete
12089  static void delete_IUpdateManagerSvc(void *p) {
12090  delete ((::IUpdateManagerSvc*)p);
12091  }
12092  static void deleteArray_IUpdateManagerSvc(void *p) {
12093  delete [] ((::IUpdateManagerSvc*)p);
12094  }
12095  static void destruct_IUpdateManagerSvc(void *p) {
12096  typedef ::IUpdateManagerSvc current_t;
12097  ((current_t*)p)->~current_t();
12098  }
12099 } // end of namespace ROOT for class ::IUpdateManagerSvc
12100 
12101 namespace ROOT {
12102  // Wrapper around operator delete
12103  static void delete_IUpdateable(void *p) {
12104  delete ((::IUpdateable*)p);
12105  }
12106  static void deleteArray_IUpdateable(void *p) {
12107  delete [] ((::IUpdateable*)p);
12108  }
12109  static void destruct_IUpdateable(void *p) {
12110  typedef ::IUpdateable current_t;
12111  ((current_t*)p)->~current_t();
12112  }
12113 } // end of namespace ROOT for class ::IUpdateable
12114 
12115 namespace ROOT {
12116  // Wrapper around operator delete
12117  static void delete_IValidity(void *p) {
12118  delete ((::IValidity*)p);
12119  }
12120  static void deleteArray_IValidity(void *p) {
12121  delete [] ((::IValidity*)p);
12122  }
12123  static void destruct_IValidity(void *p) {
12124  typedef ::IValidity current_t;
12125  ((current_t*)p)->~current_t();
12126  }
12127 } // end of namespace ROOT for class ::IValidity
12128 
12129 namespace ROOT {
12130  // Wrappers around operator new
12131  static void *new_IUpdateManagerSvccLcLPythonHelper(void *p) {
12132  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::IUpdateManagerSvc::PythonHelper : new ::IUpdateManagerSvc::PythonHelper;
12133  }
12134  static void *newArray_IUpdateManagerSvccLcLPythonHelper(Long_t nElements, void *p) {
12135  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::IUpdateManagerSvc::PythonHelper[nElements] : new ::IUpdateManagerSvc::PythonHelper[nElements];
12136  }
12137  // Wrapper around operator delete
12138  static void delete_IUpdateManagerSvccLcLPythonHelper(void *p) {
12139  delete ((::IUpdateManagerSvc::PythonHelper*)p);
12140  }
12141  static void deleteArray_IUpdateManagerSvccLcLPythonHelper(void *p) {
12142  delete [] ((::IUpdateManagerSvc::PythonHelper*)p);
12143  }
12144  static void destruct_IUpdateManagerSvccLcLPythonHelper(void *p) {
12145  typedef ::IUpdateManagerSvc::PythonHelper current_t;
12146  ((current_t*)p)->~current_t();
12147  }
12148 } // end of namespace ROOT for class ::IUpdateManagerSvc::PythonHelper
12149 
12150 namespace ROOT {
12151  static TClass *vectorlEconstsPContainedObjectmUgR_Dictionary();
12152  static void vectorlEconstsPContainedObjectmUgR_TClassManip(TClass*);
12153  static void *new_vectorlEconstsPContainedObjectmUgR(void *p = 0);
12154  static void *newArray_vectorlEconstsPContainedObjectmUgR(Long_t size, void *p);
12155  static void delete_vectorlEconstsPContainedObjectmUgR(void *p);
12156  static void deleteArray_vectorlEconstsPContainedObjectmUgR(void *p);
12157  static void destruct_vectorlEconstsPContainedObjectmUgR(void *p);
12158 
12159  // Function generating the singleton type initializer
12160  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<const ContainedObject*>*)
12161  {
12162  vector<const ContainedObject*> *ptr = 0;
12163  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<const ContainedObject*>));
12164  static ::ROOT::TGenericClassInfo
12165  instance("vector<const ContainedObject*>", -2, "vector", 214,
12166  typeid(vector<const ContainedObject*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12167  &vectorlEconstsPContainedObjectmUgR_Dictionary, isa_proxy, 4,
12168  sizeof(vector<const ContainedObject*>) );
12169  instance.SetNew(&new_vectorlEconstsPContainedObjectmUgR);
12170  instance.SetNewArray(&newArray_vectorlEconstsPContainedObjectmUgR);
12171  instance.SetDelete(&delete_vectorlEconstsPContainedObjectmUgR);
12172  instance.SetDeleteArray(&deleteArray_vectorlEconstsPContainedObjectmUgR);
12173  instance.SetDestructor(&destruct_vectorlEconstsPContainedObjectmUgR);
12174  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<const ContainedObject*> >()));
12175  return &instance;
12176  }
12177  // Static variable to force the class initialization
12178  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<const ContainedObject*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12179 
12180  // Dictionary for non-ClassDef classes
12181  static TClass *vectorlEconstsPContainedObjectmUgR_Dictionary() {
12182  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<const ContainedObject*>*)0x0)->GetClass();
12183  vectorlEconstsPContainedObjectmUgR_TClassManip(theClass);
12184  return theClass;
12185  }
12186 
12187  static void vectorlEconstsPContainedObjectmUgR_TClassManip(TClass* ){
12188  }
12189 
12190 } // end of namespace ROOT
12191 
12192 namespace ROOT {
12193  // Wrappers around operator new
12194  static void *new_vectorlEconstsPContainedObjectmUgR(void *p) {
12195  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<const ContainedObject*> : new vector<const ContainedObject*>;
12196  }
12197  static void *newArray_vectorlEconstsPContainedObjectmUgR(Long_t nElements, void *p) {
12198  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<const ContainedObject*>[nElements] : new vector<const ContainedObject*>[nElements];
12199  }
12200  // Wrapper around operator delete
12201  static void delete_vectorlEconstsPContainedObjectmUgR(void *p) {
12202  delete ((vector<const ContainedObject*>*)p);
12203  }
12204  static void deleteArray_vectorlEconstsPContainedObjectmUgR(void *p) {
12205  delete [] ((vector<const ContainedObject*>*)p);
12206  }
12207  static void destruct_vectorlEconstsPContainedObjectmUgR(void *p) {
12208  typedef vector<const ContainedObject*> current_t;
12209  ((current_t*)p)->~current_t();
12210  }
12211 } // end of namespace ROOT for class vector<const ContainedObject*>
12212 
12213 namespace ROOT {
12214  static TClass *vectorlESmartReflEObjectContainerBasegRsPgR_Dictionary();
12215  static void vectorlESmartReflEObjectContainerBasegRsPgR_TClassManip(TClass*);
12216  static void *new_vectorlESmartReflEObjectContainerBasegRsPgR(void *p = 0);
12217  static void *newArray_vectorlESmartReflEObjectContainerBasegRsPgR(Long_t size, void *p);
12218  static void delete_vectorlESmartReflEObjectContainerBasegRsPgR(void *p);
12219  static void deleteArray_vectorlESmartReflEObjectContainerBasegRsPgR(void *p);
12220  static void destruct_vectorlESmartReflEObjectContainerBasegRsPgR(void *p);
12221 
12222  // Function generating the singleton type initializer
12223  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<ObjectContainerBase> >*)
12224  {
12225  vector<SmartRef<ObjectContainerBase> > *ptr = 0;
12226  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<ObjectContainerBase> >));
12227  static ::ROOT::TGenericClassInfo
12228  instance("vector<SmartRef<ObjectContainerBase> >", -2, "vector", 214,
12229  typeid(vector<SmartRef<ObjectContainerBase> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12230  &vectorlESmartReflEObjectContainerBasegRsPgR_Dictionary, isa_proxy, 4,
12231  sizeof(vector<SmartRef<ObjectContainerBase> >) );
12232  instance.SetNew(&new_vectorlESmartReflEObjectContainerBasegRsPgR);
12233  instance.SetNewArray(&newArray_vectorlESmartReflEObjectContainerBasegRsPgR);
12234  instance.SetDelete(&delete_vectorlESmartReflEObjectContainerBasegRsPgR);
12235  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEObjectContainerBasegRsPgR);
12236  instance.SetDestructor(&destruct_vectorlESmartReflEObjectContainerBasegRsPgR);
12237  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<ObjectContainerBase> > >()));
12238  return &instance;
12239  }
12240  // Static variable to force the class initialization
12241  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<ObjectContainerBase> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12242 
12243  // Dictionary for non-ClassDef classes
12244  static TClass *vectorlESmartReflEObjectContainerBasegRsPgR_Dictionary() {
12245  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<ObjectContainerBase> >*)0x0)->GetClass();
12246  vectorlESmartReflEObjectContainerBasegRsPgR_TClassManip(theClass);
12247  return theClass;
12248  }
12249 
12250  static void vectorlESmartReflEObjectContainerBasegRsPgR_TClassManip(TClass* ){
12251  }
12252 
12253 } // end of namespace ROOT
12254 
12255 namespace ROOT {
12256  // Wrappers around operator new
12257  static void *new_vectorlESmartReflEObjectContainerBasegRsPgR(void *p) {
12258  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<ObjectContainerBase> > : new vector<SmartRef<ObjectContainerBase> >;
12259  }
12260  static void *newArray_vectorlESmartReflEObjectContainerBasegRsPgR(Long_t nElements, void *p) {
12261  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<ObjectContainerBase> >[nElements] : new vector<SmartRef<ObjectContainerBase> >[nElements];
12262  }
12263  // Wrapper around operator delete
12264  static void delete_vectorlESmartReflEObjectContainerBasegRsPgR(void *p) {
12265  delete ((vector<SmartRef<ObjectContainerBase> >*)p);
12266  }
12267  static void deleteArray_vectorlESmartReflEObjectContainerBasegRsPgR(void *p) {
12268  delete [] ((vector<SmartRef<ObjectContainerBase> >*)p);
12269  }
12270  static void destruct_vectorlESmartReflEObjectContainerBasegRsPgR(void *p) {
12271  typedef vector<SmartRef<ObjectContainerBase> > current_t;
12272  ((current_t*)p)->~current_t();
12273  }
12274 } // end of namespace ROOT for class vector<SmartRef<ObjectContainerBase> >
12275 
12276 namespace ROOT {
12277  static TClass *vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR_Dictionary();
12278  static void vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR_TClassManip(TClass*);
12279  static void *new_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p = 0);
12280  static void *newArray_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(Long_t size, void *p);
12281  static void delete_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p);
12282  static void deleteArray_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p);
12283  static void destruct_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p);
12284 
12285  // Function generating the singleton type initializer
12286  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<KeyedObject<unsigned long> > >*)
12287  {
12288  vector<SmartRef<KeyedObject<unsigned long> > > *ptr = 0;
12289  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<KeyedObject<unsigned long> > >));
12290  static ::ROOT::TGenericClassInfo
12291  instance("vector<SmartRef<KeyedObject<unsigned long> > >", -2, "vector", 214,
12292  typeid(vector<SmartRef<KeyedObject<unsigned long> > >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12293  &vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR_Dictionary, isa_proxy, 4,
12294  sizeof(vector<SmartRef<KeyedObject<unsigned long> > >) );
12295  instance.SetNew(&new_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR);
12296  instance.SetNewArray(&newArray_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR);
12297  instance.SetDelete(&delete_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR);
12298  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR);
12299  instance.SetDestructor(&destruct_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR);
12300  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<KeyedObject<unsigned long> > > >()));
12301  return &instance;
12302  }
12303  // Static variable to force the class initialization
12304  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<unsigned long> > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12305 
12306  // Dictionary for non-ClassDef classes
12307  static TClass *vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR_Dictionary() {
12308  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<unsigned long> > >*)0x0)->GetClass();
12309  vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR_TClassManip(theClass);
12310  return theClass;
12311  }
12312 
12313  static void vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR_TClassManip(TClass* ){
12314  }
12315 
12316 } // end of namespace ROOT
12317 
12318 namespace ROOT {
12319  // Wrappers around operator new
12320  static void *new_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p) {
12321  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<unsigned long> > > : new vector<SmartRef<KeyedObject<unsigned long> > >;
12322  }
12323  static void *newArray_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(Long_t nElements, void *p) {
12324  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<unsigned long> > >[nElements] : new vector<SmartRef<KeyedObject<unsigned long> > >[nElements];
12325  }
12326  // Wrapper around operator delete
12327  static void delete_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p) {
12328  delete ((vector<SmartRef<KeyedObject<unsigned long> > >*)p);
12329  }
12330  static void deleteArray_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p) {
12331  delete [] ((vector<SmartRef<KeyedObject<unsigned long> > >*)p);
12332  }
12333  static void destruct_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p) {
12334  typedef vector<SmartRef<KeyedObject<unsigned long> > > current_t;
12335  ((current_t*)p)->~current_t();
12336  }
12337 } // end of namespace ROOT for class vector<SmartRef<KeyedObject<unsigned long> > >
12338 
12339 namespace ROOT {
12340  static TClass *vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR_Dictionary();
12341  static void vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR_TClassManip(TClass*);
12342  static void *new_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p = 0);
12343  static void *newArray_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(Long_t size, void *p);
12344  static void delete_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p);
12345  static void deleteArray_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p);
12346  static void destruct_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p);
12347 
12348  // Function generating the singleton type initializer
12349  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<KeyedObject<unsigned int> > >*)
12350  {
12351  vector<SmartRef<KeyedObject<unsigned int> > > *ptr = 0;
12352  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<KeyedObject<unsigned int> > >));
12353  static ::ROOT::TGenericClassInfo
12354  instance("vector<SmartRef<KeyedObject<unsigned int> > >", -2, "vector", 214,
12355  typeid(vector<SmartRef<KeyedObject<unsigned int> > >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12356  &vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR_Dictionary, isa_proxy, 4,
12357  sizeof(vector<SmartRef<KeyedObject<unsigned int> > >) );
12358  instance.SetNew(&new_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR);
12359  instance.SetNewArray(&newArray_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR);
12360  instance.SetDelete(&delete_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR);
12361  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR);
12362  instance.SetDestructor(&destruct_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR);
12363  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<KeyedObject<unsigned int> > > >()));
12364  return &instance;
12365  }
12366  // Static variable to force the class initialization
12367  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<unsigned int> > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12368 
12369  // Dictionary for non-ClassDef classes
12370  static TClass *vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR_Dictionary() {
12371  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<unsigned int> > >*)0x0)->GetClass();
12372  vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR_TClassManip(theClass);
12373  return theClass;
12374  }
12375 
12376  static void vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR_TClassManip(TClass* ){
12377  }
12378 
12379 } // end of namespace ROOT
12380 
12381 namespace ROOT {
12382  // Wrappers around operator new
12383  static void *new_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p) {
12384  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<unsigned int> > > : new vector<SmartRef<KeyedObject<unsigned int> > >;
12385  }
12386  static void *newArray_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(Long_t nElements, void *p) {
12387  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<unsigned int> > >[nElements] : new vector<SmartRef<KeyedObject<unsigned int> > >[nElements];
12388  }
12389  // Wrapper around operator delete
12390  static void delete_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p) {
12391  delete ((vector<SmartRef<KeyedObject<unsigned int> > >*)p);
12392  }
12393  static void deleteArray_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p) {
12394  delete [] ((vector<SmartRef<KeyedObject<unsigned int> > >*)p);
12395  }
12396  static void destruct_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p) {
12397  typedef vector<SmartRef<KeyedObject<unsigned int> > > current_t;
12398  ((current_t*)p)->~current_t();
12399  }
12400 } // end of namespace ROOT for class vector<SmartRef<KeyedObject<unsigned int> > >
12401 
12402 namespace ROOT {
12403  static TClass *vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR_Dictionary();
12404  static void vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR_TClassManip(TClass*);
12405  static void *new_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p = 0);
12406  static void *newArray_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(Long_t size, void *p);
12407  static void delete_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p);
12408  static void deleteArray_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p);
12409  static void destruct_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p);
12410 
12411  // Function generating the singleton type initializer
12412  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<KeyedObject<long> > >*)
12413  {
12414  vector<SmartRef<KeyedObject<long> > > *ptr = 0;
12415  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<KeyedObject<long> > >));
12416  static ::ROOT::TGenericClassInfo
12417  instance("vector<SmartRef<KeyedObject<long> > >", -2, "vector", 214,
12418  typeid(vector<SmartRef<KeyedObject<long> > >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12419  &vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR_Dictionary, isa_proxy, 4,
12420  sizeof(vector<SmartRef<KeyedObject<long> > >) );
12421  instance.SetNew(&new_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR);
12422  instance.SetNewArray(&newArray_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR);
12423  instance.SetDelete(&delete_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR);
12424  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR);
12425  instance.SetDestructor(&destruct_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR);
12426  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<KeyedObject<long> > > >()));
12427  return &instance;
12428  }
12429  // Static variable to force the class initialization
12430  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<long> > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12431 
12432  // Dictionary for non-ClassDef classes
12433  static TClass *vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR_Dictionary() {
12434  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<long> > >*)0x0)->GetClass();
12435  vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR_TClassManip(theClass);
12436  return theClass;
12437  }
12438 
12439  static void vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR_TClassManip(TClass* ){
12440  }
12441 
12442 } // end of namespace ROOT
12443 
12444 namespace ROOT {
12445  // Wrappers around operator new
12446  static void *new_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p) {
12447  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<long> > > : new vector<SmartRef<KeyedObject<long> > >;
12448  }
12449  static void *newArray_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(Long_t nElements, void *p) {
12450  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<long> > >[nElements] : new vector<SmartRef<KeyedObject<long> > >[nElements];
12451  }
12452  // Wrapper around operator delete
12453  static void delete_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p) {
12454  delete ((vector<SmartRef<KeyedObject<long> > >*)p);
12455  }
12456  static void deleteArray_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p) {
12457  delete [] ((vector<SmartRef<KeyedObject<long> > >*)p);
12458  }
12459  static void destruct_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p) {
12460  typedef vector<SmartRef<KeyedObject<long> > > current_t;
12461  ((current_t*)p)->~current_t();
12462  }
12463 } // end of namespace ROOT for class vector<SmartRef<KeyedObject<long> > >
12464 
12465 namespace ROOT {
12466  static TClass *vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR_Dictionary();
12467  static void vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR_TClassManip(TClass*);
12468  static void *new_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p = 0);
12469  static void *newArray_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(Long_t size, void *p);
12470  static void delete_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p);
12471  static void deleteArray_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p);
12472  static void destruct_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p);
12473 
12474  // Function generating the singleton type initializer
12475  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<KeyedObject<int> > >*)
12476  {
12477  vector<SmartRef<KeyedObject<int> > > *ptr = 0;
12478  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<KeyedObject<int> > >));
12479  static ::ROOT::TGenericClassInfo
12480  instance("vector<SmartRef<KeyedObject<int> > >", -2, "vector", 214,
12481  typeid(vector<SmartRef<KeyedObject<int> > >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12482  &vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR_Dictionary, isa_proxy, 4,
12483  sizeof(vector<SmartRef<KeyedObject<int> > >) );
12484  instance.SetNew(&new_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR);
12485  instance.SetNewArray(&newArray_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR);
12486  instance.SetDelete(&delete_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR);
12487  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR);
12488  instance.SetDestructor(&destruct_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR);
12489  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<KeyedObject<int> > > >()));
12490  return &instance;
12491  }
12492  // Static variable to force the class initialization
12493  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<int> > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12494 
12495  // Dictionary for non-ClassDef classes
12496  static TClass *vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR_Dictionary() {
12497  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<int> > >*)0x0)->GetClass();
12498  vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR_TClassManip(theClass);
12499  return theClass;
12500  }
12501 
12502  static void vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR_TClassManip(TClass* ){
12503  }
12504 
12505 } // end of namespace ROOT
12506 
12507 namespace ROOT {
12508  // Wrappers around operator new
12509  static void *new_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p) {
12510  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<int> > > : new vector<SmartRef<KeyedObject<int> > >;
12511  }
12512  static void *newArray_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(Long_t nElements, void *p) {
12513  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<int> > >[nElements] : new vector<SmartRef<KeyedObject<int> > >[nElements];
12514  }
12515  // Wrapper around operator delete
12516  static void delete_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p) {
12517  delete ((vector<SmartRef<KeyedObject<int> > >*)p);
12518  }
12519  static void deleteArray_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p) {
12520  delete [] ((vector<SmartRef<KeyedObject<int> > >*)p);
12521  }
12522  static void destruct_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p) {
12523  typedef vector<SmartRef<KeyedObject<int> > > current_t;
12524  ((current_t*)p)->~current_t();
12525  }
12526 } // end of namespace ROOT for class vector<SmartRef<KeyedObject<int> > >
12527 
12528 namespace ROOT {
12529  static TClass *vectorlESmartReflEDataObjectgRsPgR_Dictionary();
12530  static void vectorlESmartReflEDataObjectgRsPgR_TClassManip(TClass*);
12531  static void *new_vectorlESmartReflEDataObjectgRsPgR(void *p = 0);
12532  static void *newArray_vectorlESmartReflEDataObjectgRsPgR(Long_t size, void *p);
12533  static void delete_vectorlESmartReflEDataObjectgRsPgR(void *p);
12534  static void deleteArray_vectorlESmartReflEDataObjectgRsPgR(void *p);
12535  static void destruct_vectorlESmartReflEDataObjectgRsPgR(void *p);
12536 
12537  // Function generating the singleton type initializer
12538  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<DataObject> >*)
12539  {
12540  vector<SmartRef<DataObject> > *ptr = 0;
12541  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<DataObject> >));
12542  static ::ROOT::TGenericClassInfo
12543  instance("vector<SmartRef<DataObject> >", -2, "vector", 214,
12544  typeid(vector<SmartRef<DataObject> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12545  &vectorlESmartReflEDataObjectgRsPgR_Dictionary, isa_proxy, 4,
12546  sizeof(vector<SmartRef<DataObject> >) );
12547  instance.SetNew(&new_vectorlESmartReflEDataObjectgRsPgR);
12548  instance.SetNewArray(&newArray_vectorlESmartReflEDataObjectgRsPgR);
12549  instance.SetDelete(&delete_vectorlESmartReflEDataObjectgRsPgR);
12550  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEDataObjectgRsPgR);
12551  instance.SetDestructor(&destruct_vectorlESmartReflEDataObjectgRsPgR);
12552  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<DataObject> > >()));
12553  return &instance;
12554  }
12555  // Static variable to force the class initialization
12556  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<DataObject> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12557 
12558  // Dictionary for non-ClassDef classes
12559  static TClass *vectorlESmartReflEDataObjectgRsPgR_Dictionary() {
12560  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<DataObject> >*)0x0)->GetClass();
12561  vectorlESmartReflEDataObjectgRsPgR_TClassManip(theClass);
12562  return theClass;
12563  }
12564 
12565  static void vectorlESmartReflEDataObjectgRsPgR_TClassManip(TClass* ){
12566  }
12567 
12568 } // end of namespace ROOT
12569 
12570 namespace ROOT {
12571  // Wrappers around operator new
12572  static void *new_vectorlESmartReflEDataObjectgRsPgR(void *p) {
12573  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<DataObject> > : new vector<SmartRef<DataObject> >;
12574  }
12575  static void *newArray_vectorlESmartReflEDataObjectgRsPgR(Long_t nElements, void *p) {
12576  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<DataObject> >[nElements] : new vector<SmartRef<DataObject> >[nElements];
12577  }
12578  // Wrapper around operator delete
12579  static void delete_vectorlESmartReflEDataObjectgRsPgR(void *p) {
12580  delete ((vector<SmartRef<DataObject> >*)p);
12581  }
12582  static void deleteArray_vectorlESmartReflEDataObjectgRsPgR(void *p) {
12583  delete [] ((vector<SmartRef<DataObject> >*)p);
12584  }
12585  static void destruct_vectorlESmartReflEDataObjectgRsPgR(void *p) {
12586  typedef vector<SmartRef<DataObject> > current_t;
12587  ((current_t*)p)->~current_t();
12588  }
12589 } // end of namespace ROOT for class vector<SmartRef<DataObject> >
12590 
12591 namespace ROOT {
12592  static TClass *vectorlESmartReflEContainedObjectgRsPgR_Dictionary();
12593  static void vectorlESmartReflEContainedObjectgRsPgR_TClassManip(TClass*);
12594  static void *new_vectorlESmartReflEContainedObjectgRsPgR(void *p = 0);
12595  static void *newArray_vectorlESmartReflEContainedObjectgRsPgR(Long_t size, void *p);
12596  static void delete_vectorlESmartReflEContainedObjectgRsPgR(void *p);
12597  static void deleteArray_vectorlESmartReflEContainedObjectgRsPgR(void *p);
12598  static void destruct_vectorlESmartReflEContainedObjectgRsPgR(void *p);
12599 
12600  // Function generating the singleton type initializer
12601  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<ContainedObject> >*)
12602  {
12603  vector<SmartRef<ContainedObject> > *ptr = 0;
12604  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<ContainedObject> >));
12605  static ::ROOT::TGenericClassInfo
12606  instance("vector<SmartRef<ContainedObject> >", -2, "vector", 214,
12607  typeid(vector<SmartRef<ContainedObject> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12608  &vectorlESmartReflEContainedObjectgRsPgR_Dictionary, isa_proxy, 4,
12609  sizeof(vector<SmartRef<ContainedObject> >) );
12610  instance.SetNew(&new_vectorlESmartReflEContainedObjectgRsPgR);
12611  instance.SetNewArray(&newArray_vectorlESmartReflEContainedObjectgRsPgR);
12612  instance.SetDelete(&delete_vectorlESmartReflEContainedObjectgRsPgR);
12613  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEContainedObjectgRsPgR);
12614  instance.SetDestructor(&destruct_vectorlESmartReflEContainedObjectgRsPgR);
12615  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<ContainedObject> > >()));
12616  return &instance;
12617  }
12618  // Static variable to force the class initialization
12619  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<ContainedObject> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12620 
12621  // Dictionary for non-ClassDef classes
12622  static TClass *vectorlESmartReflEContainedObjectgRsPgR_Dictionary() {
12623  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<ContainedObject> >*)0x0)->GetClass();
12624  vectorlESmartReflEContainedObjectgRsPgR_TClassManip(theClass);
12625  return theClass;
12626  }
12627 
12628  static void vectorlESmartReflEContainedObjectgRsPgR_TClassManip(TClass* ){
12629  }
12630 
12631 } // end of namespace ROOT
12632 
12633 namespace ROOT {
12634  // Wrappers around operator new
12635  static void *new_vectorlESmartReflEContainedObjectgRsPgR(void *p) {
12636  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<ContainedObject> > : new vector<SmartRef<ContainedObject> >;
12637  }
12638  static void *newArray_vectorlESmartReflEContainedObjectgRsPgR(Long_t nElements, void *p) {
12639  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<ContainedObject> >[nElements] : new vector<SmartRef<ContainedObject> >[nElements];
12640  }
12641  // Wrapper around operator delete
12642  static void delete_vectorlESmartReflEContainedObjectgRsPgR(void *p) {
12643  delete ((vector<SmartRef<ContainedObject> >*)p);
12644  }
12645  static void deleteArray_vectorlESmartReflEContainedObjectgRsPgR(void *p) {
12646  delete [] ((vector<SmartRef<ContainedObject> >*)p);
12647  }
12648  static void destruct_vectorlESmartReflEContainedObjectgRsPgR(void *p) {
12649  typedef vector<SmartRef<ContainedObject> > current_t;
12650  ((current_t*)p)->~current_t();
12651  }
12652 } // end of namespace ROOT for class vector<SmartRef<ContainedObject> >
12653 
12654 namespace ROOT {
12655  static TClass *vectorlELinkManagercLcLLinkmUgR_Dictionary();
12656  static void vectorlELinkManagercLcLLinkmUgR_TClassManip(TClass*);
12657  static void *new_vectorlELinkManagercLcLLinkmUgR(void *p = 0);
12658  static void *newArray_vectorlELinkManagercLcLLinkmUgR(Long_t size, void *p);
12659  static void delete_vectorlELinkManagercLcLLinkmUgR(void *p);
12660  static void deleteArray_vectorlELinkManagercLcLLinkmUgR(void *p);
12661  static void destruct_vectorlELinkManagercLcLLinkmUgR(void *p);
12662 
12663  // Function generating the singleton type initializer
12664  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<LinkManager::Link*>*)
12665  {
12666  vector<LinkManager::Link*> *ptr = 0;
12667  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<LinkManager::Link*>));
12668  static ::ROOT::TGenericClassInfo
12669  instance("vector<LinkManager::Link*>", -2, "vector", 214,
12670  typeid(vector<LinkManager::Link*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12671  &vectorlELinkManagercLcLLinkmUgR_Dictionary, isa_proxy, 4,
12672  sizeof(vector<LinkManager::Link*>) );
12673  instance.SetNew(&new_vectorlELinkManagercLcLLinkmUgR);
12674  instance.SetNewArray(&newArray_vectorlELinkManagercLcLLinkmUgR);
12675  instance.SetDelete(&delete_vectorlELinkManagercLcLLinkmUgR);
12676  instance.SetDeleteArray(&deleteArray_vectorlELinkManagercLcLLinkmUgR);
12677  instance.SetDestructor(&destruct_vectorlELinkManagercLcLLinkmUgR);
12678  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<LinkManager::Link*> >()));
12679  return &instance;
12680  }
12681  // Static variable to force the class initialization
12682  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<LinkManager::Link*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12683 
12684  // Dictionary for non-ClassDef classes
12685  static TClass *vectorlELinkManagercLcLLinkmUgR_Dictionary() {
12686  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<LinkManager::Link*>*)0x0)->GetClass();
12687  vectorlELinkManagercLcLLinkmUgR_TClassManip(theClass);
12688  return theClass;
12689  }
12690 
12691  static void vectorlELinkManagercLcLLinkmUgR_TClassManip(TClass* ){
12692  }
12693 
12694 } // end of namespace ROOT
12695 
12696 namespace ROOT {
12697  // Wrappers around operator new
12698  static void *new_vectorlELinkManagercLcLLinkmUgR(void *p) {
12699  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<LinkManager::Link*> : new vector<LinkManager::Link*>;
12700  }
12701  static void *newArray_vectorlELinkManagercLcLLinkmUgR(Long_t nElements, void *p) {
12702  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<LinkManager::Link*>[nElements] : new vector<LinkManager::Link*>[nElements];
12703  }
12704  // Wrapper around operator delete
12705  static void delete_vectorlELinkManagercLcLLinkmUgR(void *p) {
12706  delete ((vector<LinkManager::Link*>*)p);
12707  }
12708  static void deleteArray_vectorlELinkManagercLcLLinkmUgR(void *p) {
12709  delete [] ((vector<LinkManager::Link*>*)p);
12710  }
12711  static void destruct_vectorlELinkManagercLcLLinkmUgR(void *p) {
12712  typedef vector<LinkManager::Link*> current_t;
12713  ((current_t*)p)->~current_t();
12714  }
12715 } // end of namespace ROOT for class vector<LinkManager::Link*>
12716 
12717 namespace ROOT {
12718  static TClass *vectorlEDataObjectmUgR_Dictionary();
12719  static void vectorlEDataObjectmUgR_TClassManip(TClass*);
12720  static void *new_vectorlEDataObjectmUgR(void *p = 0);
12721  static void *newArray_vectorlEDataObjectmUgR(Long_t size, void *p);
12722  static void delete_vectorlEDataObjectmUgR(void *p);
12723  static void deleteArray_vectorlEDataObjectmUgR(void *p);
12724  static void destruct_vectorlEDataObjectmUgR(void *p);
12725 
12726  // Function generating the singleton type initializer
12727  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<DataObject*>*)
12728  {
12729  vector<DataObject*> *ptr = 0;
12730  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<DataObject*>));
12731  static ::ROOT::TGenericClassInfo
12732  instance("vector<DataObject*>", -2, "vector", 214,
12733  typeid(vector<DataObject*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12734  &vectorlEDataObjectmUgR_Dictionary, isa_proxy, 4,
12735  sizeof(vector<DataObject*>) );
12736  instance.SetNew(&new_vectorlEDataObjectmUgR);
12737  instance.SetNewArray(&newArray_vectorlEDataObjectmUgR);
12738  instance.SetDelete(&delete_vectorlEDataObjectmUgR);
12739  instance.SetDeleteArray(&deleteArray_vectorlEDataObjectmUgR);
12740  instance.SetDestructor(&destruct_vectorlEDataObjectmUgR);
12741  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<DataObject*> >()));
12742  return &instance;
12743  }
12744  // Static variable to force the class initialization
12745  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<DataObject*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12746 
12747  // Dictionary for non-ClassDef classes
12748  static TClass *vectorlEDataObjectmUgR_Dictionary() {
12749  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<DataObject*>*)0x0)->GetClass();
12750  vectorlEDataObjectmUgR_TClassManip(theClass);
12751  return theClass;
12752  }
12753 
12754  static void vectorlEDataObjectmUgR_TClassManip(TClass* ){
12755  }
12756 
12757 } // end of namespace ROOT
12758 
12759 namespace ROOT {
12760  // Wrappers around operator new
12761  static void *new_vectorlEDataObjectmUgR(void *p) {
12762  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<DataObject*> : new vector<DataObject*>;
12763  }
12764  static void *newArray_vectorlEDataObjectmUgR(Long_t nElements, void *p) {
12765  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<DataObject*>[nElements] : new vector<DataObject*>[nElements];
12766  }
12767  // Wrapper around operator delete
12768  static void delete_vectorlEDataObjectmUgR(void *p) {
12769  delete ((vector<DataObject*>*)p);
12770  }
12771  static void deleteArray_vectorlEDataObjectmUgR(void *p) {
12772  delete [] ((vector<DataObject*>*)p);
12773  }
12774  static void destruct_vectorlEDataObjectmUgR(void *p) {
12775  typedef vector<DataObject*> current_t;
12776  ((current_t*)p)->~current_t();
12777  }
12778 } // end of namespace ROOT for class vector<DataObject*>
12779 
12780 namespace ROOT {
12781  static TClass *vectorlEContainedObjectmUgR_Dictionary();
12782  static void vectorlEContainedObjectmUgR_TClassManip(TClass*);
12783  static void *new_vectorlEContainedObjectmUgR(void *p = 0);
12784  static void *newArray_vectorlEContainedObjectmUgR(Long_t size, void *p);
12785  static void delete_vectorlEContainedObjectmUgR(void *p);
12786  static void deleteArray_vectorlEContainedObjectmUgR(void *p);
12787  static void destruct_vectorlEContainedObjectmUgR(void *p);
12788 
12789  // Function generating the singleton type initializer
12790  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<ContainedObject*>*)
12791  {
12792  vector<ContainedObject*> *ptr = 0;
12793  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<ContainedObject*>));
12794  static ::ROOT::TGenericClassInfo
12795  instance("vector<ContainedObject*>", -2, "vector", 214,
12796  typeid(vector<ContainedObject*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12797  &vectorlEContainedObjectmUgR_Dictionary, isa_proxy, 4,
12798  sizeof(vector<ContainedObject*>) );
12799  instance.SetNew(&new_vectorlEContainedObjectmUgR);
12800  instance.SetNewArray(&newArray_vectorlEContainedObjectmUgR);
12801  instance.SetDelete(&delete_vectorlEContainedObjectmUgR);
12802  instance.SetDeleteArray(&deleteArray_vectorlEContainedObjectmUgR);
12803  instance.SetDestructor(&destruct_vectorlEContainedObjectmUgR);
12804  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<ContainedObject*> >()));
12805  return &instance;
12806  }
12807  // Static variable to force the class initialization
12808  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<ContainedObject*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12809 
12810  // Dictionary for non-ClassDef classes
12811  static TClass *vectorlEContainedObjectmUgR_Dictionary() {
12812  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<ContainedObject*>*)0x0)->GetClass();
12813  vectorlEContainedObjectmUgR_TClassManip(theClass);
12814  return theClass;
12815  }
12816 
12817  static void vectorlEContainedObjectmUgR_TClassManip(TClass* ){
12818  }
12819 
12820 } // end of namespace ROOT
12821 
12822 namespace ROOT {
12823  // Wrappers around operator new
12824  static void *new_vectorlEContainedObjectmUgR(void *p) {
12825  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<ContainedObject*> : new vector<ContainedObject*>;
12826  }
12827  static void *newArray_vectorlEContainedObjectmUgR(Long_t nElements, void *p) {
12828  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<ContainedObject*>[nElements] : new vector<ContainedObject*>[nElements];
12829  }
12830  // Wrapper around operator delete
12831  static void delete_vectorlEContainedObjectmUgR(void *p) {
12832  delete ((vector<ContainedObject*>*)p);
12833  }
12834  static void deleteArray_vectorlEContainedObjectmUgR(void *p) {
12835  delete [] ((vector<ContainedObject*>*)p);
12836  }
12837  static void destruct_vectorlEContainedObjectmUgR(void *p) {
12838  typedef vector<ContainedObject*> current_t;
12839  ((current_t*)p)->~current_t();
12840  }
12841 } // end of namespace ROOT for class vector<ContainedObject*>
12842 
12843 namespace {
12844  void TriggerDictionaryInitialization_GaudiKernelDict_Impl() {
12845  static const char* headers[] = {
12846 0 };
12847  static const char* includePaths[] = {
12848 "/builds/gaudi/Gaudi/GaudiKernel",
12849 "/builds/gaudi/Gaudi/GaudiPluginService",
12850 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/tbb/2018_U1/x86_64-centos7-gcc62-opt/include",
12851 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/ROOT/6.12.06/x86_64-centos7-gcc62-opt/include",
12852 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/Boost/1.66.0/x86_64-centos7-gcc62-opt/include",
12853 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/CppUnit/1.12.1_p1/x86_64-centos7-gcc62-opt/include",
12854 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/vectorclass/1.30/x86_64-centos7-gcc62-opt",
12855 "/builds/gaudi/Gaudi/build-gcc62/include",
12856 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/rangev3/0.3.0/x86_64-centos7-gcc62-opt/include",
12857 "/cvmfs/sft.cern.ch/lcg/releases/ROOT/6.12.06-51921/x86_64-centos7-gcc62-opt/include",
12858 "/builds/gaudi/Gaudi/build-gcc62/GaudiKernel/",
12859 0
12860  };
12861  static const char* fwdDeclCode = R"DICTFWDDCLS(
12862 #line 1 "GaudiKernelDict dictionary forward declarations' payload"
12863 #pragma clang diagnostic ignored "-Wkeyword-compat"
12864 #pragma clang diagnostic ignored "-Wignored-attributes"
12865 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
12866 extern int __Cling_Autoloading_Map;
12867 class __attribute__((annotate(R"ATTRDUMP(id@@@000000BE-0000-0000-0000-000000000000)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/ContainedObject.h"))) ContainedObject;
12868 namespace std{template <typename _Tp> class __attribute__((annotate("$clingAutoload$bits/allocator.h"))) __attribute__((annotate("$clingAutoload$string"))) allocator;
12869 }
12870 class __attribute__((annotate(R"ATTRDUMP(id@@@00000001-0000-0000-0000-000000000000)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataObject.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/ContainedObject.h"))) DataObject;
12871 template <class TYPE> class __attribute__((annotate("$clingAutoload$GaudiKernel/SmartRef.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) SmartRef;
12872 
12873 class __attribute__((annotate("$clingAutoload$GaudiKernel/ObjectContainerBase.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/ContainedObject.h"))) ObjectContainerBase;
12874 template <class KEY> class __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObject.h"))) KeyedObject;
12875 
12876 class __attribute__((annotate("$clingAutoload$GaudiKernel/StatusCode.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) StatusCode;
12877 class __attribute__((annotate("$clingAutoload$GaudiKernel/IInterface.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) InterfaceID;
12878 class __attribute__((annotate("$clingAutoload$GaudiKernel/IInterface.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IInterface;
12879 class __attribute__((annotate("$clingAutoload$GaudiKernel/IMessageSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IMessageSvc;
12880 class __attribute__((annotate("$clingAutoload$GaudiKernel/INamedInterface.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) INamedInterface;
12881 class __attribute__((annotate("$clingAutoload$GaudiKernel/IStateful.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IStateful;
12882 class __attribute__((annotate("$clingAutoload$GaudiKernel/IService.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IService;
12883 class __attribute__((annotate("$clingAutoload$GaudiKernel/IProperty.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IProperty;
12884 template <class TYPE> class __attribute__((annotate("$clingAutoload$GaudiKernel/SmartIF.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) SmartIF;
12885 
12886 class __attribute__((annotate("$clingAutoload$GaudiKernel/ISvcLocator.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) ISvcLocator;
12887 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDataProviderSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IDataProviderSvc;
12888 class __attribute__((annotate("$clingAutoload$GaudiKernel/IToolSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IToolSvc;
12889 class __attribute__((annotate("$clingAutoload$GaudiKernel/IMonitorSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IMonitorSvc;
12890 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAuditorSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IAuditorSvc;
12891 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgContextSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IAlgContextSvc;
12892 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgorithm.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IAlgorithm;
12893 class __attribute__((annotate("$clingAutoload$GaudiKernel/IConversionSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IConversionSvc;
12894 class __attribute__((annotate("$clingAutoload$GaudiKernel/IRndmGen.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IRndmGen;
12895 class __attribute__((annotate("$clingAutoload$GaudiKernel/IChronoStatSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IChronoStatSvc;
12896 class __attribute__((annotate("$clingAutoload$GaudiKernel/IHistogramSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IHistogramSvc;
12897 class __attribute__((annotate("$clingAutoload$GaudiKernel/INTupleSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) INTupleSvc;
12898 class __attribute__((annotate("$clingAutoload$GaudiKernel/IRndmGenSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IRndmGenSvc;
12899 class __attribute__((annotate("$clingAutoload$GaudiKernel/IExceptionSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IExceptionSvc;
12900 class __attribute__((annotate("$clingAutoload$GaudiKernel/ITimelineSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) ITimelineSvc;
12901 class __attribute__((annotate("$clingAutoload$GaudiKernel/IHiveWhiteBoard.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IHiveWhiteBoard;
12902 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgExecStateSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IAlgExecStateSvc;
12903 class __attribute__((annotate("$clingAutoload$GaudiKernel/ISvcManager.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) ISvcManager;
12904 class __attribute__((annotate("$clingAutoload$GaudiKernel/IIncidentSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataStreamTool.h"))) IIncidentSvc;
12905 class __attribute__((annotate("$clingAutoload$GaudiKernel/IEvtSelector.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataStreamTool.h"))) IEvtSelector;
12906 class __attribute__((annotate("$clingAutoload$GaudiKernel/ISelectStatement.h"))) ISelectStatement;
12907 class __attribute__((annotate("$clingAutoload$GaudiKernel/ICounterSvc.h"))) ICounterSvc;
12908 namespace Gaudi{namespace Details{class __attribute__((annotate("$clingAutoload$GaudiKernel/Property.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) PropertyBase;}}
12909 class __attribute__((annotate("$clingAutoload$GaudiKernel/Property.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) GaudiHandleProperty;
12910 class __attribute__((annotate("$clingAutoload$GaudiKernel/Property.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) GaudiHandleArrayProperty;
12911 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgTool.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IAlgTool;
12912 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAuditor.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IAuditor;
12913 class __attribute__((annotate(R"ATTRDUMP(pattern@@@DataObjectHandle*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataObjectHandleProperty.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) DataObjectHandleProperty;
12914 class __attribute__((annotate("$clingAutoload$GaudiKernel/GaudiHandle.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) GaudiHandleInfo;
12915 class __attribute__((annotate("$clingAutoload$GaudiKernel/GaudiHandle.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) GaudiHandleBase;
12916 class __attribute__((annotate("$clingAutoload$GaudiKernel/GaudiHandle.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) GaudiHandleArrayBase;
12917 class __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) AlgTool;
12918 class __attribute__((annotate("$clingAutoload$GaudiKernel/IChronoSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IChronoSvc;
12919 class __attribute__((annotate("$clingAutoload$GaudiKernel/IStatSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IStatSvc;
12920 class __attribute__((annotate("$clingAutoload$GaudiKernel/IConverter.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IConverter;
12921 class __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) Algorithm;
12922 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDataStreamTool.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataStreamTool.h"))) IDataStreamTool;
12923 class __attribute__((annotate("$clingAutoload$GaudiKernel/IOpaqueAddress.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataStreamTool.h"))) IOpaqueAddress;
12924 class __attribute__((annotate("$clingAutoload$GaudiKernel/Incident.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataStreamTool.h"))) Incident;
12925 class __attribute__((annotate("$clingAutoload$GaudiKernel/Service.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataStreamTool.h"))) Service;
12926 class __attribute__((annotate("$clingAutoload$GaudiKernel/GenericAddress.h"))) GenericAddress;
12927 namespace Containers{struct __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObjectManager.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObject.h"))) map;}
12928 namespace Containers{template <class SETUP> class __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObjectManager.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObject.h"))) KeyedObjectManager;
12929 }
12930 namespace Containers{struct __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObjectManager.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObject.h"))) hashmap;}
12931 namespace Containers{struct __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObjectManager.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObject.h"))) vector;}
12932 namespace Containers{struct __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObjectManager.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObject.h"))) array;}
12933 class __attribute__((annotate("$clingAutoload$GaudiKernel/LinkManager.h"))) LinkManager;
12934 class __attribute__((annotate("$clingAutoload$GaudiKernel/IJobOptionsSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/MetaData.h"))) IJobOptionsSvc;
12935 class __attribute__((annotate("$clingAutoload$GaudiKernel/MetaData.h"))) MetaData;
12936 class __attribute__((annotate("$clingAutoload$GaudiKernel/SmartRefBase.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) SmartRefBase;
12937 class __attribute__((annotate("$clingAutoload$GaudiKernel/INTuple.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) INTuple;
12938 class __attribute__((annotate(R"ATTRDUMP(pattern@@@SmartData*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/SmartDataObjectPtr.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) SmartDataObjectPtr;
12939 template <class TYPE> class __attribute__((annotate("$clingAutoload$GaudiKernel/SmartDataPtr.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) SmartDataPtr;
12940 
12941 namespace NTuple{template <class TYP> class __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) Item;
12942 }
12943 namespace NTuple{template <class TYP> class __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) Array;
12944 }
12945 namespace NTuple{template <class TYP> class __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) Matrix;
12946 }
12947 namespace NTuple{class __attribute__((annotate(R"ATTRDUMP(id@@@00000029-0000-0000-0000-000000000000)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) Directory;}
12948 namespace NTuple{class __attribute__((annotate(R"ATTRDUMP(id@@@00000028-0000-0000-0000-000000000000)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) File;}
12949 namespace NTuple{class __attribute__((annotate(R"ATTRDUMP(id@@@0000002B-0000-0000-0000-000000000000)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTupleImplementation.h"))) ColumnWiseTuple;}
12950 namespace NTuple{class __attribute__((annotate(R"ATTRDUMP(id@@@0000002A-0000-0000-0000-000000000000)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTupleImplementation.h"))) RowWiseTuple;}
12951 class __attribute__((annotate("$clingAutoload$GaudiKernel/IRegistry.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RegistryEntry.h"))) IRegistry;
12952 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Gauss;}
12953 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Exponential;}
12954 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Chi2;}
12955 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) BreitWigner;}
12956 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Landau;}
12957 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) BreitWignerCutOff;}
12958 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) StudentT;}
12959 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Gamma;}
12960 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Poisson;}
12961 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Binomial;}
12962 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Flat;}
12963 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Bit;}
12964 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) DefinedPdf;}
12965 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) GaussianTail;}
12966 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Numbers;}
12967 template <class TYPE> class __attribute__((annotate("$clingAutoload$GaudiKernel/SmartRefVector.h"))) SmartRefVector;
12968 
12969 namespace Gaudi{class __attribute__((annotate("$clingAutoload$GaudiKernel/Time.h"))) Time;}
12970 class __attribute__((annotate(R"ATTRDUMP(pattern@@@DataObjectHandle*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataObjectHandleBase.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataObjectHandle.h"))) DataObjectHandleBase;
12971 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAddressCreator.h"))) IAddressCreator;
12972 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgManager.h"))) IAlgManager;
12973 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAppMgrUI.h"))) IAppMgrUI;
12974 class __attribute__((annotate("$clingAutoload$GaudiKernel/IClassInfo.h"))) IClassInfo;
12975 class __attribute__((annotate("$clingAutoload$GaudiKernel/IClassManager.h"))) IClassManager;
12976 class __attribute__((annotate("$clingAutoload$GaudiKernel/ICounterSummarySvc.h"))) ICounterSummarySvc;
12977 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDataManagerSvc.h"))) IDataManagerSvc;
12978 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDataSourceMgr.h"))) IDataSourceMgr;
12979 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDataStoreAgent.h"))) IDataStoreAgent;
12980 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDataStoreLeaves.h"))) IDataStoreLeaves;
12981 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDetDataSvc.h"))) IDetDataSvc;
12982 class __attribute__((annotate("$clingAutoload$GaudiKernel/IEventProcessor.h"))) IEventProcessor;
12983 class __attribute__((annotate("$clingAutoload$GaudiKernel/IEventTimeDecoder.h"))) IEventTimeDecoder;
12984 class __attribute__((annotate("$clingAutoload$GaudiKernel/IHistorySvc.h"))) IHistorySvc;
12985 class __attribute__((annotate("$clingAutoload$GaudiKernel/IIncidentListener.h"))) IIncidentListener;
12986 class __attribute__((annotate("$clingAutoload$GaudiKernel/IInspectable.h"))) IInspectable;
12987 class __attribute__((annotate("$clingAutoload$GaudiKernel/IInspector.h"))) IInspector;
12988 class __attribute__((annotate("$clingAutoload$GaudiKernel/IMagneticFieldSvc.h"))) IMagneticFieldSvc;
12989 class __attribute__((annotate("$clingAutoload$GaudiKernel/IPartPropSvc.h"))) IPartPropSvc;
12990 class __attribute__((annotate("$clingAutoload$GaudiKernel/IParticlePropertySvc.h"))) IParticlePropertySvc;
12991 class __attribute__((annotate("$clingAutoload$GaudiKernel/IPartitionControl.h"))) IPartitionControl;
12992 class __attribute__((annotate("$clingAutoload$GaudiKernel/IPersistencySvc.h"))) IPersistencySvc;
12993 class __attribute__((annotate("$clingAutoload$GaudiKernel/IRndmEngine.h"))) IRndmEngine;
12994 class __attribute__((annotate("$clingAutoload$GaudiKernel/IRunable.h"))) IRunable;
12995 class __attribute__((annotate("$clingAutoload$GaudiKernel/ISerialize.h"))) ISerialize;
12996 class __attribute__((annotate("$clingAutoload$GaudiKernel/IStagerSvc.h"))) IStagerSvc;
12997 class __attribute__((annotate("$clingAutoload$GaudiKernel/IStatusCodeSvc.h"))) IStatusCodeSvc;
12998 class __attribute__((annotate("$clingAutoload$GaudiKernel/ITHistSvc.h"))) ITHistSvc;
12999 class __attribute__((annotate("$clingAutoload$GaudiKernel/IUpdateManagerSvc.h"))) IUpdateManagerSvc;
13000 class __attribute__((annotate("$clingAutoload$GaudiKernel/IUpdateable.h"))) IUpdateable;
13001 class __attribute__((annotate("$clingAutoload$GaudiKernel/IValidity.h"))) IValidity;
13002 )DICTFWDDCLS";
13003  static const char* payloadCode = R"DICTPAYLOAD(
13004 #line 1 "GaudiKernelDict dictionary payload"
13005 #ifdef _Instantiations
13006  #undef _Instantiations
13007 #endif
13008 
13009 #ifndef G__VECTOR_HAS_CLASS_ITERATOR
13010  #define G__VECTOR_HAS_CLASS_ITERATOR 1
13011 #endif
13012 #ifndef _Instantiations
13013  #define _Instantiations GaudiKernel_Instantiations
13014 #endif
13015 #ifndef _GNU_SOURCE
13016  #define _GNU_SOURCE 1
13017 #endif
13018 #ifndef unix
13019  #define unix 1
13020 #endif
13021 #ifndef f2cFortran
13022  #define f2cFortran 1
13023 #endif
13024 #ifndef linux
13025  #define linux 1
13026 #endif
13027 #ifndef GAUDI_V20_COMPAT
13028  #define GAUDI_V20_COMPAT 1
13029 #endif
13030 #ifndef BOOST_FILESYSTEM_VERSION
13031  #define BOOST_FILESYSTEM_VERSION 3
13032 #endif
13033 #ifndef BOOST_SPIRIT_USE_PHOENIX_V3
13034  #define BOOST_SPIRIT_USE_PHOENIX_V3 1
13035 #endif
13036 #ifndef PACKAGE_NAME
13037  #define PACKAGE_NAME "GaudiKernel"
13038 #endif
13039 #ifndef PACKAGE_VERSION
13040  #define PACKAGE_VERSION "v29r5"
13041 #endif
13042 #ifndef NDEBUG
13043  #define NDEBUG 1
13044 #endif
13045 
13046 #define _BACKWARD_BACKWARD_WARNING_H
13047 #define ALLOW_ALL_TYPES
13048 #include <cstdlib>
13049 #include <vector>
13050 
13051 #include "GaudiKernel/AlgTool.h"
13052 #include "GaudiKernel/Algorithm.h"
13053 #include "GaudiKernel/Bootstrap.h"
13054 #include "GaudiKernel/ContainedObject.h"
13055 #include "GaudiKernel/DataObject.h"
13056 #include "GaudiKernel/DataStreamTool.h"
13057 #include "GaudiKernel/Debugger.h"
13058 #include "GaudiKernel/Environment.h"
13059 #include "GaudiKernel/EventSelectorDataStream.h"
13060 #include "GaudiKernel/GaudiHandle.h"
13061 #include "GaudiKernel/GenericAddress.h"
13062 #include "GaudiKernel/KeyedObject.h"
13063 #include "GaudiKernel/LinkManager.h"
13064 #include "GaudiKernel/Memory.h"
13065 #include "GaudiKernel/MetaData.h"
13066 #include "GaudiKernel/NTuple.h"
13067 #include "GaudiKernel/NTupleImplementation.h"
13068 #include "GaudiKernel/ObjectVector.h"
13069 #include "GaudiKernel/Property.h"
13070 #include "GaudiKernel/RegistryEntry.h"
13071 #include "GaudiKernel/RndmGenerators.h"
13072 #include "GaudiKernel/Service.h"
13073 #include "GaudiKernel/SmartDataPtr.h"
13074 #include "GaudiKernel/SmartRefVector.h"
13075 #include "GaudiKernel/System.h"
13076 #include "GaudiKernel/Time.h"
13077 
13078 #include "GaudiKernel/DataObjectHandle.h"
13079 #include "GaudiKernel/IAddressCreator.h"
13080 #include "GaudiKernel/IAlgContextSvc.h"
13081 #include "GaudiKernel/IAlgManager.h"
13082 #include "GaudiKernel/IAlgTool.h"
13083 #include "GaudiKernel/IAlgorithm.h"
13084 #include "GaudiKernel/IAppMgrUI.h"
13085 #include "GaudiKernel/IAuditor.h"
13086 #include "GaudiKernel/IAuditorSvc.h"
13087 #include "GaudiKernel/IChronoStatSvc.h"
13088 #include "GaudiKernel/IClassInfo.h"
13089 #include "GaudiKernel/IClassManager.h"
13090 #include "GaudiKernel/IConversionSvc.h"
13091 #include "GaudiKernel/IConverter.h"
13092 #include "GaudiKernel/ICounterSummarySvc.h"
13093 #include "GaudiKernel/ICounterSvc.h"
13094 #include "GaudiKernel/IDataManagerSvc.h"
13095 #include "GaudiKernel/IDataProviderSvc.h"
13096 #include "GaudiKernel/IDataSelector.h"
13097 #include "GaudiKernel/IDataSourceMgr.h"
13098 #include "GaudiKernel/IDataStoreAgent.h"
13099 #include "GaudiKernel/IDataStoreLeaves.h"
13100 #include "GaudiKernel/IDataStreamTool.h"
13101 #include "GaudiKernel/IDetDataSvc.h"
13102 #include "GaudiKernel/IEventProcessor.h"
13103 #include "GaudiKernel/IEventTimeDecoder.h"
13104 #include "GaudiKernel/IEvtSelector.h"
13105 #include "GaudiKernel/IExceptionSvc.h"
13106 #include "GaudiKernel/IHistogramSvc.h"
13107 #include "GaudiKernel/IHistorySvc.h"
13108 #include "GaudiKernel/IIncidentListener.h"
13109 #include "GaudiKernel/IIncidentSvc.h"
13110 #include "GaudiKernel/IInspectable.h"
13111 #include "GaudiKernel/IInspector.h"
13112 #include "GaudiKernel/IInterface.h"
13113 #include "GaudiKernel/IJobOptionsSvc.h"
13114 #include "GaudiKernel/IMagneticFieldSvc.h"
13115 #include "GaudiKernel/IMessageSvc.h"
13116 #include "GaudiKernel/IMonitorSvc.h"
13117 #include "GaudiKernel/INTuple.h"
13118 #include "GaudiKernel/INTupleSvc.h"
13119 #include "GaudiKernel/INamedInterface.h"
13120 #include "GaudiKernel/IOpaqueAddress.h"
13121 #include "GaudiKernel/IPartPropSvc.h"
13122 #include "GaudiKernel/IParticlePropertySvc.h"
13123 #include "GaudiKernel/IPartitionControl.h"
13124 #include "GaudiKernel/IPersistencySvc.h"
13125 #include "GaudiKernel/IProperty.h"
13126 #include "GaudiKernel/IRegistry.h"
13127 #include "GaudiKernel/IRndmEngine.h"
13128 #include "GaudiKernel/IRndmGen.h"
13129 #include "GaudiKernel/IRndmGenSvc.h"
13130 #include "GaudiKernel/IRunable.h"
13131 #include "GaudiKernel/ISelectStatement.h"
13132 #include "GaudiKernel/ISerialize.h"
13133 #include "GaudiKernel/IService.h"
13134 #include "GaudiKernel/IStagerSvc.h"
13135 #include "GaudiKernel/IStatusCodeSvc.h"
13136 #include "GaudiKernel/ISvcLocator.h"
13137 #include "GaudiKernel/ISvcManager.h"
13138 #include "GaudiKernel/ITHistSvc.h"
13139 #include "GaudiKernel/IToolSvc.h"
13140 #include "GaudiKernel/IUpdateManagerSvc.h"
13141 #include "GaudiKernel/IUpdateable.h"
13142 #include "GaudiKernel/IValidity.h"
13143 #include "GaudiKernel/Incident.h"
13144 
13145 namespace GaudiKernelDict
13146 {
13147  struct __Instantiations : public KeyedObject<int>,
13148  public KeyedObject<unsigned int>,
13149  public KeyedObject<long>,
13150  public KeyedObject<unsigned long>,
13151  public SmartRef<DataObject>,
13152  public SmartRef<ContainedObject>,
13153  public SmartRef<ObjectContainerBase>,
13154  public SmartRef<KeyedObject<int>>,
13155  public SmartRef<KeyedObject<unsigned int>>,
13156  public SmartRef<KeyedObject<long>>,
13157  public SmartRef<KeyedObject<unsigned long>>,
13158  public SmartRefVector<DataObject>,
13159  public SmartRefVector<ContainedObject>,
13160  public SmartRefVector<ObjectContainerBase>,
13161  public SmartRefVector<KeyedObject<int>>,
13162  public SmartRefVector<KeyedObject<unsigned int>>,
13163  public SmartRefVector<KeyedObject<long>>,
13164  public SmartRefVector<KeyedObject<unsigned long>>,
13165  // public std::vector<SmartRef<ContainedObject> >,
13166  // public std::vector<SmartRef<DataObject> >,
13167  // public std::vector<SmartRef<ObjectContainerBase> >,
13168  public std::vector<LinkManager::Link*>,
13169  public std::vector<const ContainedObject*>,
13170  public std::vector<ContainedObject*> {
13171  NTuple::Item<bool> BoolItem;
13172  NTuple::Item<char> CharItem;
13173  NTuple::Item<unsigned char> UCharItem;
13174  NTuple::Item<short> ShortItem;
13175  NTuple::Item<unsigned short> UShortItem;
13176  NTuple::Item<long> LongItem;
13177  NTuple::Item<long long> LongLongItem;
13178  NTuple::Item<unsigned long> ULongItem;
13179  NTuple::Item<unsigned long long> ULongLongItem;
13180  NTuple::Item<int> IntItem;
13181  NTuple::Item<unsigned int> UIntItem;
13182  NTuple::Item<float> FloatItem;
13183  NTuple::Item<double> DoubleItem;
13184  NTuple::Array<bool> BoolArray;
13185  NTuple::Array<char> CharArray;
13186  NTuple::Array<unsigned char> UCharArray;
13187  NTuple::Array<short> ShortArray;
13188  NTuple::Array<unsigned short> UShortArray;
13189  NTuple::Array<long> LongArray;
13190  NTuple::Array<unsigned long> ULongArray;
13191  NTuple::Array<int> IntArray;
13192  NTuple::Array<unsigned int> UIntArray;
13193  NTuple::Array<float> FloatArray;
13194  NTuple::Array<double> DoubleArray;
13195  NTuple::Matrix<bool> BoolMatrix;
13196  NTuple::Matrix<char> CharMatrix;
13197  NTuple::Matrix<unsigned char> UCharMatrix;
13198  NTuple::Matrix<short> ShortMatrix;
13199  NTuple::Matrix<unsigned short> UShortMatrix;
13200  NTuple::Matrix<long> LongMatrix;
13201  NTuple::Matrix<unsigned long> ULongMatrix;
13202  NTuple::Matrix<int> IntMatrix;
13203  NTuple::Matrix<unsigned int> UIntMatrix;
13204  NTuple::Matrix<float> FloatMatrix;
13205  NTuple::Matrix<double> DoubleMatrix;
13206 
13207  SmartDataPtr<DataObject> p1;
13208  SmartDataPtr<ObjectContainerBase> p2;
13209  __Instantiations() : p1( 0, "" ), p2( 0, "" ) {}
13210  };
13211 }
13212 
13213 class IUpdateManagerSvc::PythonHelper
13214 {
13215 public:
13216  static StatusCode update( IUpdateManagerSvc* ums, void* obj ) { return ums->i_update( obj ); }
13217 
13218  static void invalidate( IUpdateManagerSvc* ums, void* obj ) { return ums->i_invalidate( obj ); }
13219 };
13220 
13221 #ifdef _WIN32
13222 // FIXME: (MCl) The generated dictionary produce a few warnings C4345, since I
13223 // cannot fix them, I just disable them.
13224 
13225 // Disable warning C4345: behavior change: an object of POD type constructed with an initializer of the
13226 // form () will be default-initialized
13227 #pragma warning( disable : 4345 )
13228 #endif
13229 
13230 #ifdef __ICC
13231 // disable icc warning #858: type qualifier on return type is meaningless
13232 // ... a lot of noise produced by the dictionary
13233 #pragma warning( disable : 858 )
13234 // disable icc remark #2259: non-pointer conversion from "int" to "const char &" may lose significant bits
13235 // Strange, things like NTuple::Item<char> produce this warning, as if the operation between chars are done
13236 // converting them to integers first.
13237 #pragma warning( disable : 2259 )
13238 // disable icc remark #177: variable "X" was declared but never referenced
13239 #pragma warning( disable : 177 )
13240 #endif
13241 
13242 #undef _BACKWARD_BACKWARD_WARNING_H
13243 )DICTPAYLOAD";
13244  static const char* classesHeaders[]={
13245 "", payloadCode, "@",
13246 "AlgTool", payloadCode, "@",
13247 "Algorithm", payloadCode, "@",
13248 "ContainedObject", payloadCode, "@",
13249 "Containers::KeyedObjectManager<Containers::array>", payloadCode, "@",
13250 "Containers::KeyedObjectManager<Containers::hashmap>", payloadCode, "@",
13251 "Containers::KeyedObjectManager<Containers::map>", payloadCode, "@",
13252 "Containers::KeyedObjectManager<Containers::vector>", payloadCode, "@",
13253 "DataObject", payloadCode, "@",
13254 "DataObjectHandleBase", payloadCode, "@",
13255 "DataObjectHandleProperty", payloadCode, "@",
13256 "Gaudi::CounterSummary::SaveType", payloadCode, "@",
13257 "Gaudi::Details::PropertyBase", payloadCode, "@",
13258 "Gaudi::Details::operator<<", payloadCode, "@",
13259 "Gaudi::Histos::book", payloadCode, "@",
13260 "Gaudi::Parsers::parse", payloadCode, "@",
13261 "Gaudi::PluginService::Debug", payloadCode, "@",
13262 "Gaudi::PluginService::Details::demangle", payloadCode, "@",
13263 "Gaudi::PluginService::Details::getCreator", payloadCode, "@",
13264 "Gaudi::PluginService::Details::logger", payloadCode, "@",
13265 "Gaudi::PluginService::Details::setLogger", payloadCode, "@",
13266 "Gaudi::PluginService::SetDebug", payloadCode, "@",
13267 "Gaudi::StateMachine::ChangeState", payloadCode, "@",
13268 "Gaudi::StateMachine::State", payloadCode, "@",
13269 "Gaudi::StateMachine::Transition", payloadCode, "@",
13270 "Gaudi::StateMachine::operator<<", payloadCode, "@",
13271 "Gaudi::Time", payloadCode, "@",
13272 "Gaudi::Utils::formatAsTableRow", payloadCode, "@",
13273 "Gaudi::Utils::getProperty", payloadCode, "@",
13274 "Gaudi::Utils::hasProperty", payloadCode, "@",
13275 "Gaudi::Utils::iequal", payloadCode, "@",
13276 "Gaudi::Utils::operator<<", payloadCode, "@",
13277 "Gaudi::Utils::setProperty", payloadCode, "@",
13278 "Gaudi::Utils::toStream", payloadCode, "@",
13279 "Gaudi::createApplicationMgr", payloadCode, "@",
13280 "Gaudi::createApplicationMgrEx", payloadCode, "@",
13281 "Gaudi::createInstance", payloadCode, "@",
13282 "Gaudi::getCurrentDataObject", payloadCode, "@",
13283 "Gaudi::hash_value", payloadCode, "@",
13284 "Gaudi::operator!=", payloadCode, "@",
13285 "Gaudi::operator+", payloadCode, "@",
13286 "Gaudi::operator-", payloadCode, "@",
13287 "Gaudi::operator<", payloadCode, "@",
13288 "Gaudi::operator<<", payloadCode, "@",
13289 "Gaudi::operator<=", payloadCode, "@",
13290 "Gaudi::operator==", payloadCode, "@",
13291 "Gaudi::operator>", payloadCode, "@",
13292 "Gaudi::operator>=", payloadCode, "@",
13293 "Gaudi::popCurrentDataObject", payloadCode, "@",
13294 "Gaudi::pushCurrentDataObject", payloadCode, "@",
13295 "Gaudi::setInstance", payloadCode, "@",
13296 "Gaudi::svcLocator", payloadCode, "@",
13297 "GaudiHandleArrayBase", payloadCode, "@",
13298 "GaudiHandleArrayProperty", payloadCode, "@",
13299 "GaudiHandleBase", payloadCode, "@",
13300 "GaudiHandleInfo", payloadCode, "@",
13301 "GaudiHandleProperty", payloadCode, "@",
13302 "GenericAddress", payloadCode, "@",
13303 "IAddressCreator", payloadCode, "@",
13304 "IAlgContextSvc", payloadCode, "@",
13305 "IAlgManager", payloadCode, "@",
13306 "IAlgTool", payloadCode, "@",
13307 "IAlgorithm", payloadCode, "@",
13308 "IAppMgrUI", payloadCode, "@",
13309 "IAuditor", payloadCode, "@",
13310 "IAuditorSvc", payloadCode, "@",
13311 "IChronoStatSvc", payloadCode, "@",
13312 "IChronoSvc", payloadCode, "@",
13313 "IClassInfo", payloadCode, "@",
13314 "IClassManager", payloadCode, "@",
13315 "IConversionSvc", payloadCode, "@",
13316 "IConverter", payloadCode, "@",
13317 "ICounterSummarySvc", payloadCode, "@",
13318 "ICounterSvc", payloadCode, "@",
13319 "IDataManagerSvc", payloadCode, "@",
13320 "IDataProviderSvc", payloadCode, "@",
13321 "IDataSelector", payloadCode, "@",
13322 "IDataSourceMgr", payloadCode, "@",
13323 "IDataStoreAgent", payloadCode, "@",
13324 "IDataStoreLeaves", payloadCode, "@",
13325 "IDataStreamTool", payloadCode, "@",
13326 "IDetDataSvc", payloadCode, "@",
13327 "IEventProcessor", payloadCode, "@",
13328 "IEventTimeDecoder", payloadCode, "@",
13329 "IEvtSelector", payloadCode, "@",
13330 "IExceptionSvc", payloadCode, "@",
13331 "IHistogramSvc", payloadCode, "@",
13332 "IHistorySvc", payloadCode, "@",
13333 "IIncidentListener", payloadCode, "@",
13334 "IIncidentSvc", payloadCode, "@",
13335 "IInspectable", payloadCode, "@",
13336 "IInspector", payloadCode, "@",
13337 "IInterface", payloadCode, "@",
13338 "IJobOptionsSvc", payloadCode, "@",
13339 "IMagneticFieldSvc", payloadCode, "@",
13340 "IMessageSvc", payloadCode, "@",
13341 "IMonitorSvc", payloadCode, "@",
13342 "INTuple", payloadCode, "@",
13343 "INTupleSvc", payloadCode, "@",
13344 "INamedInterface", payloadCode, "@",
13345 "IOpaqueAddress", payloadCode, "@",
13346 "IPartPropSvc", payloadCode, "@",
13347 "IParticlePropertySvc", payloadCode, "@",
13348 "IPartitionControl", payloadCode, "@",
13349 "IPersistencySvc", payloadCode, "@",
13350 "IProperty", payloadCode, "@",
13351 "IRegistry", payloadCode, "@",
13352 "IRndmEngine", payloadCode, "@",
13353 "IRndmGen", payloadCode, "@",
13354 "IRndmGen::Param", payloadCode, "@",
13355 "IRndmGenSvc", payloadCode, "@",
13356 "IRunable", payloadCode, "@",
13357 "ISelectStatement", payloadCode, "@",
13358 "ISerialize", payloadCode, "@",
13359 "IService", payloadCode, "@",
13360 "IStagerSvc", payloadCode, "@",
13361 "IStatSvc", payloadCode, "@",
13362 "IStateful", payloadCode, "@",
13363 "IStatusCodeSvc", payloadCode, "@",
13364 "ISvcLocator", payloadCode, "@",
13365 "ISvcManager", payloadCode, "@",
13366 "ITHistSvc", payloadCode, "@",
13367 "IToolSvc", payloadCode, "@",
13368 "IUpdateManagerSvc", payloadCode, "@",
13369 "IUpdateManagerSvc::PythonHelper", payloadCode, "@",
13370 "IUpdateable", payloadCode, "@",
13371 "IValidity", payloadCode, "@",
13372 "Incident", payloadCode, "@",
13373 "InterfaceID", payloadCode, "@",
13374 "KeyedObject<int>", payloadCode, "@",
13375 "KeyedObject<long>", payloadCode, "@",
13376 "KeyedObject<unsigned int>", payloadCode, "@",
13377 "KeyedObject<unsigned long>", payloadCode, "@",
13378 "LinkManager", payloadCode, "@",
13379 "LinkManager::Link", payloadCode, "@",
13380 "MSG::Color", payloadCode, "@",
13381 "MSG::Level", payloadCode, "@",
13382 "MetaData", payloadCode, "@",
13383 "NTuple::Array<IOpaqueAddress*>", payloadCode, "@",
13384 "NTuple::Array<bool>", payloadCode, "@",
13385 "NTuple::Array<char>", payloadCode, "@",
13386 "NTuple::Array<double>", payloadCode, "@",
13387 "NTuple::Array<float>", payloadCode, "@",
13388 "NTuple::Array<int>", payloadCode, "@",
13389 "NTuple::Array<long>", payloadCode, "@",
13390 "NTuple::Array<short>", payloadCode, "@",
13391 "NTuple::Array<unsigned char>", payloadCode, "@",
13392 "NTuple::Array<unsigned int>", payloadCode, "@",
13393 "NTuple::Array<unsigned long>", payloadCode, "@",
13394 "NTuple::Array<unsigned short>", payloadCode, "@",
13395 "NTuple::ColumnWiseTuple", payloadCode, "@",
13396 "NTuple::Directory", payloadCode, "@",
13397 "NTuple::File", payloadCode, "@",
13398 "NTuple::Item<Long64_t>", payloadCode, "@",
13399 "NTuple::Item<ULong64_t>", payloadCode, "@",
13400 "NTuple::Item<bool>", payloadCode, "@",
13401 "NTuple::Item<char>", payloadCode, "@",
13402 "NTuple::Item<double>", payloadCode, "@",
13403 "NTuple::Item<float>", payloadCode, "@",
13404 "NTuple::Item<int>", payloadCode, "@",
13405 "NTuple::Item<long>", payloadCode, "@",
13406 "NTuple::Item<short>", payloadCode, "@",
13407 "NTuple::Item<unsigned char>", payloadCode, "@",
13408 "NTuple::Item<unsigned int>", payloadCode, "@",
13409 "NTuple::Item<unsigned long>", payloadCode, "@",
13410 "NTuple::Item<unsigned short>", payloadCode, "@",
13411 "NTuple::Matrix<IOpaqueAddress*>", payloadCode, "@",
13412 "NTuple::Matrix<bool>", payloadCode, "@",
13413 "NTuple::Matrix<char>", payloadCode, "@",
13414 "NTuple::Matrix<double>", payloadCode, "@",
13415 "NTuple::Matrix<float>", payloadCode, "@",
13416 "NTuple::Matrix<int>", payloadCode, "@",
13417 "NTuple::Matrix<long>", payloadCode, "@",
13418 "NTuple::Matrix<short>", payloadCode, "@",
13419 "NTuple::Matrix<unsigned char>", payloadCode, "@",
13420 "NTuple::Matrix<unsigned int>", payloadCode, "@",
13421 "NTuple::Matrix<unsigned long>", payloadCode, "@",
13422 "NTuple::Matrix<unsigned short>", payloadCode, "@",
13423 "NTuple::RowWiseTuple", payloadCode, "@",
13424 "ObjectContainerBase", payloadCode, "@",
13425 "Rndm::Binomial", payloadCode, "@",
13426 "Rndm::Bit", payloadCode, "@",
13427 "Rndm::BreitWigner", payloadCode, "@",
13428 "Rndm::BreitWignerCutOff", payloadCode, "@",
13429 "Rndm::Chi2", payloadCode, "@",
13430 "Rndm::DefinedPdf", payloadCode, "@",
13431 "Rndm::Exponential", payloadCode, "@",
13432 "Rndm::Flat", payloadCode, "@",
13433 "Rndm::Gamma", payloadCode, "@",
13434 "Rndm::Gauss", payloadCode, "@",
13435 "Rndm::GaussianTail", payloadCode, "@",
13436 "Rndm::Landau", payloadCode, "@",
13437 "Rndm::Numbers", payloadCode, "@",
13438 "Rndm::Poisson", payloadCode, "@",
13439 "Rndm::StudentT", payloadCode, "@",
13440 "Service", payloadCode, "@",
13441 "SmartDataObjectPtr", payloadCode, "@",
13442 "SmartDataPtr<DataObject>", payloadCode, "@",
13443 "SmartDataPtr<ObjectContainerBase>", payloadCode, "@",
13444 "SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>", payloadCode, "@",
13445 "SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>", payloadCode, "@",
13446 "SmartIF<IAlgContextSvc>", payloadCode, "@",
13447 "SmartIF<IAlgExecStateSvc>", payloadCode, "@",
13448 "SmartIF<IAlgorithm>", payloadCode, "@",
13449 "SmartIF<IAuditorSvc>", payloadCode, "@",
13450 "SmartIF<IChronoStatSvc>", payloadCode, "@",
13451 "SmartIF<IConversionSvc>", payloadCode, "@",
13452 "SmartIF<ICounterSvc>", payloadCode, "@",
13453 "SmartIF<IDataProviderSvc>", payloadCode, "@",
13454 "SmartIF<IEvtSelector>", payloadCode, "@",
13455 "SmartIF<IExceptionSvc>", payloadCode, "@",
13456 "SmartIF<IHistogramSvc>", payloadCode, "@",
13457 "SmartIF<IHiveWhiteBoard>", payloadCode, "@",
13458 "SmartIF<IIncidentSvc>", payloadCode, "@",
13459 "SmartIF<IMessageSvc>", payloadCode, "@",
13460 "SmartIF<IMonitorSvc>", payloadCode, "@",
13461 "SmartIF<INTupleSvc>", payloadCode, "@",
13462 "SmartIF<IProperty>", payloadCode, "@",
13463 "SmartIF<IRndmGen>", payloadCode, "@",
13464 "SmartIF<IRndmGenSvc>", payloadCode, "@",
13465 "SmartIF<ISelectStatement>", payloadCode, "@",
13466 "SmartIF<IService>", payloadCode, "@",
13467 "SmartIF<ISvcLocator>", payloadCode, "@",
13468 "SmartIF<ISvcManager>", payloadCode, "@",
13469 "SmartIF<ITimelineSvc>", payloadCode, "@",
13470 "SmartIF<IToolSvc>", payloadCode, "@",
13471 "SmartRef<ContainedObject>", payloadCode, "@",
13472 "SmartRef<DataObject>", payloadCode, "@",
13473 "SmartRef<KeyedObject<int> >", payloadCode, "@",
13474 "SmartRef<KeyedObject<long> >", payloadCode, "@",
13475 "SmartRef<KeyedObject<unsigned int> >", payloadCode, "@",
13476 "SmartRef<KeyedObject<unsigned long> >", payloadCode, "@",
13477 "SmartRef<ObjectContainerBase>", payloadCode, "@",
13478 "SmartRefBase", payloadCode, "@",
13479 "SmartRefVector<ContainedObject>", payloadCode, "@",
13480 "SmartRefVector<DataObject>", payloadCode, "@",
13481 "SmartRefVector<KeyedObject<int> >", payloadCode, "@",
13482 "SmartRefVector<KeyedObject<long> >", payloadCode, "@",
13483 "SmartRefVector<KeyedObject<unsigned int> >", payloadCode, "@",
13484 "SmartRefVector<KeyedObject<unsigned long> >", payloadCode, "@",
13485 "SmartRefVector<ObjectContainerBase>", payloadCode, "@",
13486 "StatusCode", payloadCode, "@",
13487 "System::accountName", payloadCode, "@",
13488 "System::adjustMemory", payloadCode, "@",
13489 "System::adjustTime", payloadCode, "@",
13490 "System::affinityMask", payloadCode, "@",
13491 "System::argc", payloadCode, "@",
13492 "System::argv", payloadCode, "@",
13493 "System::backTrace", payloadCode, "@",
13494 "System::basePriority", payloadCode, "@",
13495 "System::breakExecution", payloadCode, "@",
13496 "System::cmdLineArgs", payloadCode, "@",
13497 "System::cpuTime", payloadCode, "@",
13498 "System::creationTime", payloadCode, "@",
13499 "System::currentTime", payloadCode, "@",
13500 "System::ellapsedTime", payloadCode, "@",
13501 "System::exeHandle", payloadCode, "@",
13502 "System::exeName", payloadCode, "@",
13503 "System::exitStatus", payloadCode, "@",
13504 "System::getEnv", payloadCode, "@",
13505 "System::getErrorString", payloadCode, "@",
13506 "System::getLastError", payloadCode, "@",
13507 "System::getLastErrorString", payloadCode, "@",
13508 "System::getProcedureByName", payloadCode, "@",
13509 "System::getProcessTime", payloadCode, "@",
13510 "System::getStackLevel", payloadCode, "@",
13511 "System::homeDirectory", payloadCode, "@",
13512 "System::hostName", payloadCode, "@",
13513 "System::instructionsetLevel", payloadCode, "@",
13514 "System::isEnvSet", payloadCode, "@",
13515 "System::kernelTime", payloadCode, "@",
13516 "System::linkedModules", payloadCode, "@",
13517 "System::loadDynamicLib", payloadCode, "@",
13518 "System::machineType", payloadCode, "@",
13519 "System::mappedMemory", payloadCode, "@",
13520 "System::mappedMemoryPeak", payloadCode, "@",
13521 "System::maxMemoryLimit", payloadCode, "@",
13522 "System::minMemoryLimit", payloadCode, "@",
13523 "System::moduleHandle", payloadCode, "@",
13524 "System::moduleName", payloadCode, "@",
13525 "System::moduleNameFull", payloadCode, "@",
13526 "System::moduleType", payloadCode, "@",
13527 "System::nonPagedMemory", payloadCode, "@",
13528 "System::nonPagedMemoryLimit", payloadCode, "@",
13529 "System::nonPagedMemoryPeak", payloadCode, "@",
13530 "System::numCmdLineArgs", payloadCode, "@",
13531 "System::numPageFault", payloadCode, "@",
13532 "System::osName", payloadCode, "@",
13533 "System::osVersion", payloadCode, "@",
13534 "System::pagedMemory", payloadCode, "@",
13535 "System::pagedMemoryLimit", payloadCode, "@",
13536 "System::pagedMemoryPeak", payloadCode, "@",
13537 "System::pagefileUsage", payloadCode, "@",
13538 "System::pagefileUsageLimit", payloadCode, "@",
13539 "System::pagefileUsagePeak", payloadCode, "@",
13540 "System::parentID", payloadCode, "@",
13541 "System::priorityBoost", payloadCode, "@",
13542 "System::procID", payloadCode, "@",
13543 "System::processHandle", payloadCode, "@",
13544 "System::remainingTime", payloadCode, "@",
13545 "System::resolveEnv", payloadCode, "@",
13546 "System::setEnv", payloadCode, "@",
13547 "System::setModuleHandle", payloadCode, "@",
13548 "System::systemStart", payloadCode, "@",
13549 "System::tempDirectory", payloadCode, "@",
13550 "System::threadSelf", payloadCode, "@",
13551 "System::tickCount", payloadCode, "@",
13552 "System::typeinfoName", payloadCode, "@",
13553 "System::unloadDynamicLib", payloadCode, "@",
13554 "System::upTime", payloadCode, "@",
13555 "System::userTime", payloadCode, "@",
13556 "System::virtualMemory", payloadCode, "@",
13557 "System::virtualMemoryLimit", payloadCode, "@",
13558 "System::virtualMemoryPeak", payloadCode, "@",
13559 nullptr};
13560 
13561  static bool isInitialized = false;
13562  if (!isInitialized) {
13563  TROOT::RegisterModule("GaudiKernelDict",
13564  headers, includePaths, payloadCode, fwdDeclCode,
13565  TriggerDictionaryInitialization_GaudiKernelDict_Impl, {}, classesHeaders);
13566  isInitialized = true;
13567  }
13568  }
13569  static struct DictInit {
13570  DictInit() {
13571  TriggerDictionaryInitialization_GaudiKernelDict_Impl();
13572  }
13573  } __TheDictionaryInitializer;
13574 }
13575 void TriggerDictionaryInitialization_GaudiKernelDict() {
13576  TriggerDictionaryInitialization_GaudiKernelDict_Impl();
13577 }
IToolSvc
The interface implemented by the IToolSvc base class.
Definition: IToolSvc.h:19
Rndm::Bit
Parameters for the bit value generation: returns values 0 and 1.
Definition: RndmGenerators.h:301
ISvcLocator
The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to loc...
Definition: ISvcLocator.h:25
IConverter
The data converters are responsible to translate data from one representation into another...
Definition: IConverter.h:58
IDataStoreLeaves
Interface for a tool or service that returns a list of leaves (paths) in a transient store...
Definition: IDataStoreLeaves.h:15
ISelectStatement
A select statement can either contain.
Definition: ISelectStatement.h:32
KeyedObject
Definition of the templated KeyedObject class.
Definition: KeyedObject.h:30
ISvcManager
The ISvcManager is the interface implemented by the Service Factory in the Application Manager to sup...
Definition: ISvcManager.h:28
NTuple::Matrix
Class acting as a smart pointer holding a N tuple _Item.
Definition: NTuple.h:53
Rndm::Poisson
Parameters for the Poisson distributed random number generation with a given mean.
Definition: RndmGenerators.h:226
IClassInfo
Data base class allowing to store persistent type information.
Definition: IClassInfo.h:12
ICounterSvc
Create / access multi purpose counters.
Definition: ICounterSvc.h:75
IEvtSelector
The Event Selector Interface.
Definition: IEvtSelector.h:18
IRndmGen
Definition of a interface for a generic random number generators.
Definition: IRndmGen.h:34
IAddressCreator
IAddressCreator interface definition.
Definition: IAddressCreator.h:28
IAlgManager
The IAlgManager is the interface implemented by the Algorithm Factory in the Application Manager to s...
Definition: IAlgManager.h:27
std
STL namespace.
SmartRefBase
User example objects: SmartRefBase.
Definition: SmartRefBase.h:47
Rndm::Gauss
Parameters for the Gauss random number generation.
Definition: RndmGenerators.h:23
GenericAddress
Generic Transient Address.
Definition: GenericAddress.h:20
IEventTimeDecoder
Interface that a Tool that decodes the event time has to implement.
Definition: IEventTimeDecoder.h:19
IDataProviderSvc
Data provider interface definition.
Definition: IDataProviderSvc.h:45
DataObjectHandleProperty
DataObjectHandleProperty.h GaudiKernel/DataObjectHandleProperty.h.
Definition: DataObjectHandleProperty.h:23
ROOT::GenerateInitInstance
TGenericClassInfo * GenerateInitInstance(const ::IUpdateManagerSvc::PythonHelper *)
Definition: GaudiKernelDict.cpp:8660
SmartRefVector
Kernel objects: SmartRefVector.
Definition: SmartRefVector.h:55
INTuple
NTuple interface class definition.
Definition: INTuple.h:82
IChronoStatSvc
The IChronoStatSvc is the interface implemented by the ChronoStatService.
Definition: IChronoStatSvc.h:33
SmartDataObjectPtr::ObjectLoader
Helper class to configure smart pointer functionality.
Definition: SmartDataObjectPtr.h:37
IMagneticFieldSvc
The interface to the MagneticFieldSvc.
Definition: IMagneticFieldSvc.h:37
Rndm::Numbers
Random number accessor This small class encapsulates the use of the random number generator...
Definition: RndmGenerators.h:396
InterfaceID
Interface ID class.
Definition: IInterface.h:29
IJobOptionsSvc
Main interface for the JobOptions service.
Definition: IJobOptionsSvc.h:20
IIncidentListener
The interface implemented by any class wanting to listen to Incidents.
Definition: IIncidentListener.h:15
IMonitorSvc
Definition of the IMonitorSvc interface, which publishes Gaudi variables to outside monitoring proces...
Definition: IMonitorSvc.h:24
IInspector
Inspector base class.
Definition: IInspector.h:15
Gaudi::Time
Based on seal::Time.
Definition: Time.h:237
IRndmGenSvc
Random Generator service interface definition Definition of a interface for a service to access rando...
Definition: IRndmGenSvc.h:35
IService
General service interface definition.
Definition: IService.h:18
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
Rndm::Flat
Parameters for the flat random number generation within boundaries [minimum, maximum].
Definition: RndmGenerators.h:276
IInterface
Definition of the basic interface.
Definition: IInterface.h:277
IUpdateManagerSvc::PythonHelper
Helper class implemented in the python dictionary to allow access from python to template member func...
IMessageSvc
The IMessage is the interface implemented by the message service.
Definition: IMessageSvc.h:38
IRegistry
The IRegistry represents the entry door to the environment any data object residing in a transient da...
Definition: IRegistry.h:22
IHistogramSvc
Definition of the IHistogramSvc interface class.
Definition: IHistogramSvc.h:47
IInspectable
Interface definition of an inspectable object.
Definition: IInspectable.h:17
Gaudi::Details::PropertyBase
PropertyBase base class allowing PropertyBase* collections to be "homogeneous".
Definition: Property.h:32
IUpdateManagerSvc
Interface class to the Update Manager service.
Definition: IUpdateManagerSvc.h:144
Genfun::GaudiMathImplementation::ROOT::R__UseDummy
R__UseDummy(_R__UNIQUE_DICT_(Init))
NTuple::Item< bool >
Specialization acting as a smart pointer holding a N tuple _Item.
Definition: NTuple.h:318
IAlgorithm
The IAlgorithm is the interface implemented by the Algorithm base class.
Definition: IAlgorithm.h:28
Rndm::StudentT
Parameters for the StudentT distributed random number generation.
Definition: RndmGenerators.h:175
Rndm::Binomial
Parameters for the Binomial distributed random number generation.
Definition: RndmGenerators.h:250
ContainedObject
All classes that their objects may be contained in an LHCb ObjectContainer (e.g.
Definition: ContainedObject.h:31
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:79
INamedInterface
IInterface compliant class extending IInterface with the name() method.
Definition: INamedInterface.h:15
IAppMgrUI
Application Manager User Interface.
Definition: IAppMgrUI.h:20
GaudiHandleArrayBase
Base class of array&#39;s of various gaudihandles.
Definition: GaudiHandle.h:348
SmartDataObjectPtr
A small class used to access easily (and efficiently) data items residing in data stores...
Definition: SmartDataObjectPtr.h:32
Rndm::Landau
Parameters for the Landau distributed random number generation.
Definition: RndmGenerators.h:119
Rndm::Chi2
Parameters for the Chi2 distributed random number generation.
Definition: RndmGenerators.h:71
std::vector
STL class.
IDataStoreAgent
Generic data agent interface.
Definition: IDataStoreAgent.h:16
SmartDataObjectPtr::ObjectFinder
Helper class to configure smart pointer functionality.
Definition: SmartDataObjectPtr.h:44
Rndm::BreitWignerCutOff
Parameters for the BreitWigner distributed random number generation with cut off;.
Definition: RndmGenerators.h:145
DataObjectHandleBase
DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h.
Definition: DataObjectHandleBase.h:25
SmartDataStorePtr
A small class used to access easily (and efficiently) data items residing in data stores...
Definition: SmartDataStorePtr.h:45
IPartitionControl
Create / access partitions.
Definition: IPartitionControl.h:66
Rndm::Gamma
Parameters for the Gamma distributed random number generation.
Definition: RndmGenerators.h:198
IParticlePropertySvc
This class is an interface to the ParticlePropertySvc.
Definition: IParticlePropertySvc.h:18
Incident
Base class for all Incidents (computing events).
Definition: Incident.h:17
Containers::KeyedObjectManager
KeyedObjectManager Class to manage keyed objects.
Definition: KeyedObjectManager.h:46
AlgTool
Base class from which all the concrete tool classes should be derived.
Definition: AlgTool.h:48
IAlgTool
The interface implemented by the AlgTool base class.
Definition: IAlgTool.h:23
IRunable
Runable interface definition.
Definition: IRunable.h:18
SmartDataPtr
A small class used to access easily (and efficiently) data items residing in data stores...
Definition: SmartDataPtr.h:47
IEventProcessor
The IEventProcessor is the interface to process events.
Definition: IEventProcessor.h:16
IDataSourceMgr
IDataSourceMgr interface definition.
Definition: IDataSourceMgr.h:14
IValidity
Interface for objects with a validity.
Definition: IValidity.h:12
IAlgContextSvc
An abstract interface for Algorithm Context Service.
Definition: IAlgContextSvc.h:23
IPersistencySvc
Data persistency service interface.
Definition: IPersistencySvc.h:19
IRndmEngine
Definition of a interface for a generic random number generator giving randomly distributed numbers i...
Definition: IRndmEngine.h:19
TriggerDictionaryInitialization_GaudiKernelDict
void TriggerDictionaryInitialization_GaudiKernelDict()
Definition: GaudiKernelDict.cpp:13575
ObjectContainerBase
ObjectContainerBase is the base class for Gaudi container classes.
Definition: ObjectContainerBase.h:19
IStatSvc
"Stat"-related part of interface IChronoStatSvc
Definition: IStatSvc.h:25
IStateful
Interface for classes that implement the Gaudi State Machine.
Definition: IStateful.h:16
GaudiHandleBase
Base class to handles to be used in lieu of naked pointers to various Gaudi components.
Definition: GaudiHandle.h:83
IOpaqueAddress
Opaque address interface definition.
Definition: IOpaqueAddress.h:23
IUpdateable
Object update interface definition.
Definition: IUpdateable.h:15
NTuple::Item
Class acting as a smart pointer holding a N tuple _Item.
Definition: NTuple.h:49
IProperty
The IProperty is the basic interface for all components which have properties that can be set or get...
Definition: IProperty.h:20
Rndm::GaussianTail
Parameters for the Gaussian tail number generation.
Definition: RndmGenerators.h:358
IAuditorSvc
The interface implemented by the IAuditorSvc base class.
Definition: IAuditorSvc.h:15
Service
Base class for all services.
Definition: Service.h:36
Rndm::DefinedPdf
Generate a random number Generator following generally distributed random values, given a user-define...
Definition: RndmGenerators.h:330
NTuple::Array
Class acting as a smart pointer holding a N tuple _Item.
Definition: NTuple.h:51
IClassManager
The IClassManager is the interface implemented by the generic Factory in the Application Manager to s...
Definition: IClassManager.h:18
Rndm::Exponential
Parameters for the Gauss random number generation.
Definition: RndmGenerators.h:50
DataObject
A DataObject is the base class of any identifiable object on any data store.
Definition: DataObject.h:30
NTuple::Directory
Small class representing an N tuple directory in the transient store.
Definition: NTuple.h:986
IAuditor
The IAuditor is the interface implmented by the AlgAuditor base class.
Definition: IAuditor.h:18
ISerialize
Object serialization interface definition.
Definition: ISerialize.h:17
ICounterSummarySvc
Simple service interface to collect counters to persist in a summary file.
Definition: ICounterSummarySvc.h:36
IExceptionSvc
The abstract interface for exception handling service.
Definition: IExceptionSvc.h:24
IChronoSvc
"Chrono"-related part of interface IChronoStatSvc
Definition: IChronoSvc.h:31
IIncidentSvc
The interface implemented by the IncidentSvc service.
Definition: IIncidentSvc.h:23
Rndm::BreitWigner
Parameters for the BreitWigner distributed random number generation.
Definition: RndmGenerators.h:94
NTuple::File
Small class representing an N tuple file in the transient store.
Definition: NTuple.h:1002
IHistorySvc
Definition of the IHistorySvc interface class.
Definition: IHistorySvc.h:31