The Gaudi Framework  v30r3 (a5ef0a68)
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", 51,
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 *SmartIFlEIServicegR_Dictionary();
337  static void SmartIFlEIServicegR_TClassManip(TClass*);
338  static void *new_SmartIFlEIServicegR(void *p = 0);
339  static void *newArray_SmartIFlEIServicegR(Long_t size, void *p);
340  static void delete_SmartIFlEIServicegR(void *p);
341  static void deleteArray_SmartIFlEIServicegR(void *p);
342  static void destruct_SmartIFlEIServicegR(void *p);
343 
344  // Function generating the singleton type initializer
345  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IService>*)
346  {
347  ::SmartIF<IService> *ptr = 0;
348  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IService>));
349  static ::ROOT::TGenericClassInfo
350  instance("SmartIF<IService>", "GaudiKernel/SmartIF.h", 19,
351  typeid(::SmartIF<IService>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
352  &SmartIFlEIServicegR_Dictionary, isa_proxy, 4,
353  sizeof(::SmartIF<IService>) );
354  instance.SetNew(&new_SmartIFlEIServicegR);
355  instance.SetNewArray(&newArray_SmartIFlEIServicegR);
356  instance.SetDelete(&delete_SmartIFlEIServicegR);
357  instance.SetDeleteArray(&deleteArray_SmartIFlEIServicegR);
358  instance.SetDestructor(&destruct_SmartIFlEIServicegR);
359  return &instance;
360  }
361  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IService>*)
362  {
363  return GenerateInitInstanceLocal((::SmartIF<IService>*)0);
364  }
365  // Static variable to force the class initialization
366  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IService>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
367 
368  // Dictionary for non-ClassDef classes
369  static TClass *SmartIFlEIServicegR_Dictionary() {
370  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IService>*)0x0)->GetClass();
371  SmartIFlEIServicegR_TClassManip(theClass);
372  return theClass;
373  }
374 
375  static void SmartIFlEIServicegR_TClassManip(TClass* ){
376  }
377 
378 } // end of namespace ROOT
379 
380 namespace ROOT {
381  static TClass *SmartIFlEISvcLocatorgR_Dictionary();
382  static void SmartIFlEISvcLocatorgR_TClassManip(TClass*);
383  static void *new_SmartIFlEISvcLocatorgR(void *p = 0);
384  static void *newArray_SmartIFlEISvcLocatorgR(Long_t size, void *p);
385  static void delete_SmartIFlEISvcLocatorgR(void *p);
386  static void deleteArray_SmartIFlEISvcLocatorgR(void *p);
387  static void destruct_SmartIFlEISvcLocatorgR(void *p);
388 
389  // Function generating the singleton type initializer
390  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<ISvcLocator>*)
391  {
392  ::SmartIF<ISvcLocator> *ptr = 0;
393  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<ISvcLocator>));
394  static ::ROOT::TGenericClassInfo
395  instance("SmartIF<ISvcLocator>", "GaudiKernel/SmartIF.h", 19,
396  typeid(::SmartIF<ISvcLocator>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
397  &SmartIFlEISvcLocatorgR_Dictionary, isa_proxy, 4,
398  sizeof(::SmartIF<ISvcLocator>) );
399  instance.SetNew(&new_SmartIFlEISvcLocatorgR);
400  instance.SetNewArray(&newArray_SmartIFlEISvcLocatorgR);
401  instance.SetDelete(&delete_SmartIFlEISvcLocatorgR);
402  instance.SetDeleteArray(&deleteArray_SmartIFlEISvcLocatorgR);
403  instance.SetDestructor(&destruct_SmartIFlEISvcLocatorgR);
404  return &instance;
405  }
406  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<ISvcLocator>*)
407  {
408  return GenerateInitInstanceLocal((::SmartIF<ISvcLocator>*)0);
409  }
410  // Static variable to force the class initialization
411  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<ISvcLocator>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
412 
413  // Dictionary for non-ClassDef classes
414  static TClass *SmartIFlEISvcLocatorgR_Dictionary() {
415  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<ISvcLocator>*)0x0)->GetClass();
416  SmartIFlEISvcLocatorgR_TClassManip(theClass);
417  return theClass;
418  }
419 
420  static void SmartIFlEISvcLocatorgR_TClassManip(TClass* ){
421  }
422 
423 } // end of namespace ROOT
424 
425 namespace ROOT {
426  static TClass *SmartIFlEIMessageSvcgR_Dictionary();
427  static void SmartIFlEIMessageSvcgR_TClassManip(TClass*);
428  static void *new_SmartIFlEIMessageSvcgR(void *p = 0);
429  static void *newArray_SmartIFlEIMessageSvcgR(Long_t size, void *p);
430  static void delete_SmartIFlEIMessageSvcgR(void *p);
431  static void deleteArray_SmartIFlEIMessageSvcgR(void *p);
432  static void destruct_SmartIFlEIMessageSvcgR(void *p);
433 
434  // Function generating the singleton type initializer
435  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IMessageSvc>*)
436  {
437  ::SmartIF<IMessageSvc> *ptr = 0;
438  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IMessageSvc>));
439  static ::ROOT::TGenericClassInfo
440  instance("SmartIF<IMessageSvc>", "GaudiKernel/SmartIF.h", 19,
441  typeid(::SmartIF<IMessageSvc>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
442  &SmartIFlEIMessageSvcgR_Dictionary, isa_proxy, 4,
443  sizeof(::SmartIF<IMessageSvc>) );
444  instance.SetNew(&new_SmartIFlEIMessageSvcgR);
445  instance.SetNewArray(&newArray_SmartIFlEIMessageSvcgR);
446  instance.SetDelete(&delete_SmartIFlEIMessageSvcgR);
447  instance.SetDeleteArray(&deleteArray_SmartIFlEIMessageSvcgR);
448  instance.SetDestructor(&destruct_SmartIFlEIMessageSvcgR);
449  return &instance;
450  }
451  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IMessageSvc>*)
452  {
453  return GenerateInitInstanceLocal((::SmartIF<IMessageSvc>*)0);
454  }
455  // Static variable to force the class initialization
456  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IMessageSvc>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
457 
458  // Dictionary for non-ClassDef classes
459  static TClass *SmartIFlEIMessageSvcgR_Dictionary() {
460  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IMessageSvc>*)0x0)->GetClass();
461  SmartIFlEIMessageSvcgR_TClassManip(theClass);
462  return theClass;
463  }
464 
465  static void SmartIFlEIMessageSvcgR_TClassManip(TClass* ){
466  }
467 
468 } // end of namespace ROOT
469 
470 namespace ROOT {
471  static TClass *SmartIFlEIPropertygR_Dictionary();
472  static void SmartIFlEIPropertygR_TClassManip(TClass*);
473  static void *new_SmartIFlEIPropertygR(void *p = 0);
474  static void *newArray_SmartIFlEIPropertygR(Long_t size, void *p);
475  static void delete_SmartIFlEIPropertygR(void *p);
476  static void deleteArray_SmartIFlEIPropertygR(void *p);
477  static void destruct_SmartIFlEIPropertygR(void *p);
478 
479  // Function generating the singleton type initializer
480  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartIF<IProperty>*)
481  {
482  ::SmartIF<IProperty> *ptr = 0;
483  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartIF<IProperty>));
484  static ::ROOT::TGenericClassInfo
485  instance("SmartIF<IProperty>", "GaudiKernel/SmartIF.h", 19,
486  typeid(::SmartIF<IProperty>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
487  &SmartIFlEIPropertygR_Dictionary, isa_proxy, 4,
488  sizeof(::SmartIF<IProperty>) );
489  instance.SetNew(&new_SmartIFlEIPropertygR);
490  instance.SetNewArray(&newArray_SmartIFlEIPropertygR);
491  instance.SetDelete(&delete_SmartIFlEIPropertygR);
492  instance.SetDeleteArray(&deleteArray_SmartIFlEIPropertygR);
493  instance.SetDestructor(&destruct_SmartIFlEIPropertygR);
494  return &instance;
495  }
496  TGenericClassInfo *GenerateInitInstance(const ::SmartIF<IProperty>*)
497  {
498  return GenerateInitInstanceLocal((::SmartIF<IProperty>*)0);
499  }
500  // Static variable to force the class initialization
501  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartIF<IProperty>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
502 
503  // Dictionary for non-ClassDef classes
504  static TClass *SmartIFlEIPropertygR_Dictionary() {
505  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartIF<IProperty>*)0x0)->GetClass();
506  SmartIFlEIPropertygR_TClassManip(theClass);
507  return theClass;
508  }
509 
510  static void SmartIFlEIPropertygR_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 *ISvcManager_Dictionary();
1417  static void ISvcManager_TClassManip(TClass*);
1418  static void delete_ISvcManager(void *p);
1419  static void deleteArray_ISvcManager(void *p);
1420  static void destruct_ISvcManager(void *p);
1421 
1422  // Function generating the singleton type initializer
1423  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ISvcManager*)
1424  {
1425  ::ISvcManager *ptr = 0;
1426  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ISvcManager));
1427  static ::ROOT::TGenericClassInfo
1428  instance("ISvcManager", "GaudiKernel/ISvcManager.h", 28,
1429  typeid(::ISvcManager), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1430  &ISvcManager_Dictionary, isa_proxy, 4,
1431  sizeof(::ISvcManager) );
1432  instance.SetDelete(&delete_ISvcManager);
1433  instance.SetDeleteArray(&deleteArray_ISvcManager);
1434  instance.SetDestructor(&destruct_ISvcManager);
1435  return &instance;
1436  }
1437  TGenericClassInfo *GenerateInitInstance(const ::ISvcManager*)
1438  {
1439  return GenerateInitInstanceLocal((::ISvcManager*)0);
1440  }
1441  // Static variable to force the class initialization
1442  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ISvcManager*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1443 
1444  // Dictionary for non-ClassDef classes
1445  static TClass *ISvcManager_Dictionary() {
1446  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ISvcManager*)0x0)->GetClass();
1447  ISvcManager_TClassManip(theClass);
1448  return theClass;
1449  }
1450 
1451  static void ISvcManager_TClassManip(TClass* ){
1452  }
1453 
1454 } // end of namespace ROOT
1455 
1456 namespace ROOT {
1457  static TClass *ISvcLocator_Dictionary();
1458  static void ISvcLocator_TClassManip(TClass*);
1459  static void delete_ISvcLocator(void *p);
1460  static void deleteArray_ISvcLocator(void *p);
1461  static void destruct_ISvcLocator(void *p);
1462 
1463  // Function generating the singleton type initializer
1464  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ISvcLocator*)
1465  {
1466  ::ISvcLocator *ptr = 0;
1467  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ISvcLocator));
1468  static ::ROOT::TGenericClassInfo
1469  instance("ISvcLocator", "GaudiKernel/ISvcLocator.h", 25,
1470  typeid(::ISvcLocator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1471  &ISvcLocator_Dictionary, isa_proxy, 4,
1472  sizeof(::ISvcLocator) );
1473  instance.SetDelete(&delete_ISvcLocator);
1474  instance.SetDeleteArray(&deleteArray_ISvcLocator);
1475  instance.SetDestructor(&destruct_ISvcLocator);
1476  return &instance;
1477  }
1478  TGenericClassInfo *GenerateInitInstance(const ::ISvcLocator*)
1479  {
1480  return GenerateInitInstanceLocal((::ISvcLocator*)0);
1481  }
1482  // Static variable to force the class initialization
1483  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ISvcLocator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1484 
1485  // Dictionary for non-ClassDef classes
1486  static TClass *ISvcLocator_Dictionary() {
1487  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ISvcLocator*)0x0)->GetClass();
1488  ISvcLocator_TClassManip(theClass);
1489  return theClass;
1490  }
1491 
1492  static void ISvcLocator_TClassManip(TClass* ){
1493  }
1494 
1495 } // end of namespace ROOT
1496 
1497 namespace ROOT {
1498  static TClass *IAlgTool_Dictionary();
1499  static void IAlgTool_TClassManip(TClass*);
1500  static void delete_IAlgTool(void *p);
1501  static void deleteArray_IAlgTool(void *p);
1502  static void destruct_IAlgTool(void *p);
1503 
1504  // Function generating the singleton type initializer
1505  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAlgTool*)
1506  {
1507  ::IAlgTool *ptr = 0;
1508  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAlgTool));
1509  static ::ROOT::TGenericClassInfo
1510  instance("IAlgTool", "GaudiKernel/IAlgTool.h", 23,
1511  typeid(::IAlgTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1512  &IAlgTool_Dictionary, isa_proxy, 4,
1513  sizeof(::IAlgTool) );
1514  instance.SetDelete(&delete_IAlgTool);
1515  instance.SetDeleteArray(&deleteArray_IAlgTool);
1516  instance.SetDestructor(&destruct_IAlgTool);
1517  return &instance;
1518  }
1519  TGenericClassInfo *GenerateInitInstance(const ::IAlgTool*)
1520  {
1521  return GenerateInitInstanceLocal((::IAlgTool*)0);
1522  }
1523  // Static variable to force the class initialization
1524  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAlgTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1525 
1526  // Dictionary for non-ClassDef classes
1527  static TClass *IAlgTool_Dictionary() {
1528  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAlgTool*)0x0)->GetClass();
1529  IAlgTool_TClassManip(theClass);
1530  return theClass;
1531  }
1532 
1533  static void IAlgTool_TClassManip(TClass* ){
1534  }
1535 
1536 } // end of namespace ROOT
1537 
1538 namespace ROOT {
1539  static TClass *IAuditor_Dictionary();
1540  static void IAuditor_TClassManip(TClass*);
1541  static void delete_IAuditor(void *p);
1542  static void deleteArray_IAuditor(void *p);
1543  static void destruct_IAuditor(void *p);
1544 
1545  // Function generating the singleton type initializer
1546  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAuditor*)
1547  {
1548  ::IAuditor *ptr = 0;
1549  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAuditor));
1550  static ::ROOT::TGenericClassInfo
1551  instance("IAuditor", "GaudiKernel/IAuditor.h", 18,
1552  typeid(::IAuditor), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1553  &IAuditor_Dictionary, isa_proxy, 4,
1554  sizeof(::IAuditor) );
1555  instance.SetDelete(&delete_IAuditor);
1556  instance.SetDeleteArray(&deleteArray_IAuditor);
1557  instance.SetDestructor(&destruct_IAuditor);
1558  return &instance;
1559  }
1560  TGenericClassInfo *GenerateInitInstance(const ::IAuditor*)
1561  {
1562  return GenerateInitInstanceLocal((::IAuditor*)0);
1563  }
1564  // Static variable to force the class initialization
1565  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAuditor*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1566 
1567  // Dictionary for non-ClassDef classes
1568  static TClass *IAuditor_Dictionary() {
1569  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAuditor*)0x0)->GetClass();
1570  IAuditor_TClassManip(theClass);
1571  return theClass;
1572  }
1573 
1574  static void IAuditor_TClassManip(TClass* ){
1575  }
1576 
1577 } // end of namespace ROOT
1578 
1579 namespace ROOT {
1580  static TClass *IAuditorSvc_Dictionary();
1581  static void IAuditorSvc_TClassManip(TClass*);
1582  static void delete_IAuditorSvc(void *p);
1583  static void deleteArray_IAuditorSvc(void *p);
1584  static void destruct_IAuditorSvc(void *p);
1585 
1586  // Function generating the singleton type initializer
1587  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAuditorSvc*)
1588  {
1589  ::IAuditorSvc *ptr = 0;
1590  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAuditorSvc));
1591  static ::ROOT::TGenericClassInfo
1592  instance("IAuditorSvc", "GaudiKernel/IAuditorSvc.h", 15,
1593  typeid(::IAuditorSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1594  &IAuditorSvc_Dictionary, isa_proxy, 4,
1595  sizeof(::IAuditorSvc) );
1596  instance.SetDelete(&delete_IAuditorSvc);
1597  instance.SetDeleteArray(&deleteArray_IAuditorSvc);
1598  instance.SetDestructor(&destruct_IAuditorSvc);
1599  return &instance;
1600  }
1601  TGenericClassInfo *GenerateInitInstance(const ::IAuditorSvc*)
1602  {
1603  return GenerateInitInstanceLocal((::IAuditorSvc*)0);
1604  }
1605  // Static variable to force the class initialization
1606  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAuditorSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1607 
1608  // Dictionary for non-ClassDef classes
1609  static TClass *IAuditorSvc_Dictionary() {
1610  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAuditorSvc*)0x0)->GetClass();
1611  IAuditorSvc_TClassManip(theClass);
1612  return theClass;
1613  }
1614 
1615  static void IAuditorSvc_TClassManip(TClass* ){
1616  }
1617 
1618 } // end of namespace ROOT
1619 
1620 namespace ROOT {
1621  static TClass *IDataProviderSvc_Dictionary();
1622  static void IDataProviderSvc_TClassManip(TClass*);
1623  static void delete_IDataProviderSvc(void *p);
1624  static void deleteArray_IDataProviderSvc(void *p);
1625  static void destruct_IDataProviderSvc(void *p);
1626 
1627  // Function generating the singleton type initializer
1628  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDataProviderSvc*)
1629  {
1630  ::IDataProviderSvc *ptr = 0;
1631  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDataProviderSvc));
1632  static ::ROOT::TGenericClassInfo
1633  instance("IDataProviderSvc", "GaudiKernel/IDataProviderSvc.h", 46,
1634  typeid(::IDataProviderSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1635  &IDataProviderSvc_Dictionary, isa_proxy, 4,
1636  sizeof(::IDataProviderSvc) );
1637  instance.SetDelete(&delete_IDataProviderSvc);
1638  instance.SetDeleteArray(&deleteArray_IDataProviderSvc);
1639  instance.SetDestructor(&destruct_IDataProviderSvc);
1640  return &instance;
1641  }
1642  TGenericClassInfo *GenerateInitInstance(const ::IDataProviderSvc*)
1643  {
1644  return GenerateInitInstanceLocal((::IDataProviderSvc*)0);
1645  }
1646  // Static variable to force the class initialization
1647  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDataProviderSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1648 
1649  // Dictionary for non-ClassDef classes
1650  static TClass *IDataProviderSvc_Dictionary() {
1651  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDataProviderSvc*)0x0)->GetClass();
1652  IDataProviderSvc_TClassManip(theClass);
1653  return theClass;
1654  }
1655 
1656  static void IDataProviderSvc_TClassManip(TClass* ){
1657  }
1658 
1659 } // end of namespace ROOT
1660 
1661 namespace ROOT {
1662  static TClass *IMonitorSvc_Dictionary();
1663  static void IMonitorSvc_TClassManip(TClass*);
1664  static void delete_IMonitorSvc(void *p);
1665  static void deleteArray_IMonitorSvc(void *p);
1666  static void destruct_IMonitorSvc(void *p);
1667 
1668  // Function generating the singleton type initializer
1669  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IMonitorSvc*)
1670  {
1671  ::IMonitorSvc *ptr = 0;
1672  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IMonitorSvc));
1673  static ::ROOT::TGenericClassInfo
1674  instance("IMonitorSvc", "GaudiKernel/IMonitorSvc.h", 24,
1675  typeid(::IMonitorSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1676  &IMonitorSvc_Dictionary, isa_proxy, 4,
1677  sizeof(::IMonitorSvc) );
1678  instance.SetDelete(&delete_IMonitorSvc);
1679  instance.SetDeleteArray(&deleteArray_IMonitorSvc);
1680  instance.SetDestructor(&destruct_IMonitorSvc);
1681  return &instance;
1682  }
1683  TGenericClassInfo *GenerateInitInstance(const ::IMonitorSvc*)
1684  {
1685  return GenerateInitInstanceLocal((::IMonitorSvc*)0);
1686  }
1687  // Static variable to force the class initialization
1688  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IMonitorSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1689 
1690  // Dictionary for non-ClassDef classes
1691  static TClass *IMonitorSvc_Dictionary() {
1692  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IMonitorSvc*)0x0)->GetClass();
1693  IMonitorSvc_TClassManip(theClass);
1694  return theClass;
1695  }
1696 
1697  static void IMonitorSvc_TClassManip(TClass* ){
1698  }
1699 
1700 } // end of namespace ROOT
1701 
1702 namespace ROOT {
1703  static TClass *IProperty_Dictionary();
1704  static void IProperty_TClassManip(TClass*);
1705  static void delete_IProperty(void *p);
1706  static void deleteArray_IProperty(void *p);
1707  static void destruct_IProperty(void *p);
1708 
1709  // Function generating the singleton type initializer
1710  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IProperty*)
1711  {
1712  ::IProperty *ptr = 0;
1713  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IProperty));
1714  static ::ROOT::TGenericClassInfo
1715  instance("IProperty", "GaudiKernel/IProperty.h", 20,
1716  typeid(::IProperty), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1717  &IProperty_Dictionary, isa_proxy, 4,
1718  sizeof(::IProperty) );
1719  instance.SetDelete(&delete_IProperty);
1720  instance.SetDeleteArray(&deleteArray_IProperty);
1721  instance.SetDestructor(&destruct_IProperty);
1722  return &instance;
1723  }
1724  TGenericClassInfo *GenerateInitInstance(const ::IProperty*)
1725  {
1726  return GenerateInitInstanceLocal((::IProperty*)0);
1727  }
1728  // Static variable to force the class initialization
1729  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IProperty*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1730 
1731  // Dictionary for non-ClassDef classes
1732  static TClass *IProperty_Dictionary() {
1733  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IProperty*)0x0)->GetClass();
1734  IProperty_TClassManip(theClass);
1735  return theClass;
1736  }
1737 
1738  static void IProperty_TClassManip(TClass* ){
1739  }
1740 
1741 } // end of namespace ROOT
1742 
1743 namespace ROOT {
1744  static TClass *IToolSvc_Dictionary();
1745  static void IToolSvc_TClassManip(TClass*);
1746  static void delete_IToolSvc(void *p);
1747  static void deleteArray_IToolSvc(void *p);
1748  static void destruct_IToolSvc(void *p);
1749 
1750  // Function generating the singleton type initializer
1751  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IToolSvc*)
1752  {
1753  ::IToolSvc *ptr = 0;
1754  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IToolSvc));
1755  static ::ROOT::TGenericClassInfo
1756  instance("IToolSvc", "GaudiKernel/IToolSvc.h", 19,
1757  typeid(::IToolSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1758  &IToolSvc_Dictionary, isa_proxy, 4,
1759  sizeof(::IToolSvc) );
1760  instance.SetDelete(&delete_IToolSvc);
1761  instance.SetDeleteArray(&deleteArray_IToolSvc);
1762  instance.SetDestructor(&destruct_IToolSvc);
1763  return &instance;
1764  }
1765  TGenericClassInfo *GenerateInitInstance(const ::IToolSvc*)
1766  {
1767  return GenerateInitInstanceLocal((::IToolSvc*)0);
1768  }
1769  // Static variable to force the class initialization
1770  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IToolSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1771 
1772  // Dictionary for non-ClassDef classes
1773  static TClass *IToolSvc_Dictionary() {
1774  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IToolSvc*)0x0)->GetClass();
1775  IToolSvc_TClassManip(theClass);
1776  return theClass;
1777  }
1778 
1779  static void IToolSvc_TClassManip(TClass* ){
1780  }
1781 
1782 } // end of namespace ROOT
1783 
1784 namespace ROOT {
1785  static TClass *GaudicLcLDetailscLcLPropertyBase_Dictionary();
1786  static void GaudicLcLDetailscLcLPropertyBase_TClassManip(TClass*);
1787  static void delete_GaudicLcLDetailscLcLPropertyBase(void *p);
1788  static void deleteArray_GaudicLcLDetailscLcLPropertyBase(void *p);
1789  static void destruct_GaudicLcLDetailscLcLPropertyBase(void *p);
1790 
1791  // Function generating the singleton type initializer
1792  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Details::PropertyBase*)
1793  {
1794  ::Gaudi::Details::PropertyBase *ptr = 0;
1795  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Details::PropertyBase));
1796  static ::ROOT::TGenericClassInfo
1797  instance("Gaudi::Details::PropertyBase", "GaudiKernel/Property.h", 32,
1798  typeid(::Gaudi::Details::PropertyBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1799  &GaudicLcLDetailscLcLPropertyBase_Dictionary, isa_proxy, 4,
1800  sizeof(::Gaudi::Details::PropertyBase) );
1801  instance.SetDelete(&delete_GaudicLcLDetailscLcLPropertyBase);
1802  instance.SetDeleteArray(&deleteArray_GaudicLcLDetailscLcLPropertyBase);
1803  instance.SetDestructor(&destruct_GaudicLcLDetailscLcLPropertyBase);
1804  return &instance;
1805  }
1806  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Details::PropertyBase*)
1807  {
1808  return GenerateInitInstanceLocal((::Gaudi::Details::PropertyBase*)0);
1809  }
1810  // Static variable to force the class initialization
1811  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Details::PropertyBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1812 
1813  // Dictionary for non-ClassDef classes
1814  static TClass *GaudicLcLDetailscLcLPropertyBase_Dictionary() {
1815  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Details::PropertyBase*)0x0)->GetClass();
1816  GaudicLcLDetailscLcLPropertyBase_TClassManip(theClass);
1817  return theClass;
1818  }
1819 
1820  static void GaudicLcLDetailscLcLPropertyBase_TClassManip(TClass* ){
1821  }
1822 
1823 } // end of namespace ROOT
1824 
1825 namespace ROOT {
1826  static TClass *GaudiHandleProperty_Dictionary();
1827  static void GaudiHandleProperty_TClassManip(TClass*);
1828  static void delete_GaudiHandleProperty(void *p);
1829  static void deleteArray_GaudiHandleProperty(void *p);
1830  static void destruct_GaudiHandleProperty(void *p);
1831 
1832  // Function generating the singleton type initializer
1833  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHandleProperty*)
1834  {
1835  ::GaudiHandleProperty *ptr = 0;
1836  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHandleProperty));
1837  static ::ROOT::TGenericClassInfo
1838  instance("GaudiHandleProperty", "GaudiKernel/Property.h", 899,
1839  typeid(::GaudiHandleProperty), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1840  &GaudiHandleProperty_Dictionary, isa_proxy, 4,
1841  sizeof(::GaudiHandleProperty) );
1842  instance.SetDelete(&delete_GaudiHandleProperty);
1843  instance.SetDeleteArray(&deleteArray_GaudiHandleProperty);
1844  instance.SetDestructor(&destruct_GaudiHandleProperty);
1845  return &instance;
1846  }
1847  TGenericClassInfo *GenerateInitInstance(const ::GaudiHandleProperty*)
1848  {
1849  return GenerateInitInstanceLocal((::GaudiHandleProperty*)0);
1850  }
1851  // Static variable to force the class initialization
1852  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHandleProperty*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1853 
1854  // Dictionary for non-ClassDef classes
1855  static TClass *GaudiHandleProperty_Dictionary() {
1856  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHandleProperty*)0x0)->GetClass();
1857  GaudiHandleProperty_TClassManip(theClass);
1858  return theClass;
1859  }
1860 
1861  static void GaudiHandleProperty_TClassManip(TClass* ){
1862  }
1863 
1864 } // end of namespace ROOT
1865 
1866 namespace ROOT {
1867  static TClass *GaudiHandleArrayProperty_Dictionary();
1868  static void GaudiHandleArrayProperty_TClassManip(TClass*);
1869  static void delete_GaudiHandleArrayProperty(void *p);
1870  static void deleteArray_GaudiHandleArrayProperty(void *p);
1871  static void destruct_GaudiHandleArrayProperty(void *p);
1872 
1873  // Function generating the singleton type initializer
1874  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHandleArrayProperty*)
1875  {
1876  ::GaudiHandleArrayProperty *ptr = 0;
1877  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHandleArrayProperty));
1878  static ::ROOT::TGenericClassInfo
1879  instance("GaudiHandleArrayProperty", "GaudiKernel/Property.h", 939,
1880  typeid(::GaudiHandleArrayProperty), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1881  &GaudiHandleArrayProperty_Dictionary, isa_proxy, 4,
1882  sizeof(::GaudiHandleArrayProperty) );
1883  instance.SetDelete(&delete_GaudiHandleArrayProperty);
1884  instance.SetDeleteArray(&deleteArray_GaudiHandleArrayProperty);
1885  instance.SetDestructor(&destruct_GaudiHandleArrayProperty);
1886  return &instance;
1887  }
1888  TGenericClassInfo *GenerateInitInstance(const ::GaudiHandleArrayProperty*)
1889  {
1890  return GenerateInitInstanceLocal((::GaudiHandleArrayProperty*)0);
1891  }
1892  // Static variable to force the class initialization
1893  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHandleArrayProperty*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1894 
1895  // Dictionary for non-ClassDef classes
1896  static TClass *GaudiHandleArrayProperty_Dictionary() {
1897  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHandleArrayProperty*)0x0)->GetClass();
1898  GaudiHandleArrayProperty_TClassManip(theClass);
1899  return theClass;
1900  }
1901 
1902  static void GaudiHandleArrayProperty_TClassManip(TClass* ){
1903  }
1904 
1905 } // end of namespace ROOT
1906 
1907 namespace ROOT {
1908  static TClass *DataObjectHandleProperty_Dictionary();
1909  static void DataObjectHandleProperty_TClassManip(TClass*);
1910  static void delete_DataObjectHandleProperty(void *p);
1911  static void deleteArray_DataObjectHandleProperty(void *p);
1912  static void destruct_DataObjectHandleProperty(void *p);
1913 
1914  // Function generating the singleton type initializer
1915  static TGenericClassInfo *GenerateInitInstanceLocal(const ::DataObjectHandleProperty*)
1916  {
1917  ::DataObjectHandleProperty *ptr = 0;
1918  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::DataObjectHandleProperty));
1919  static ::ROOT::TGenericClassInfo
1920  instance("DataObjectHandleProperty", "GaudiKernel/DataObjectHandleProperty.h", 23,
1921  typeid(::DataObjectHandleProperty), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1922  &DataObjectHandleProperty_Dictionary, isa_proxy, 4,
1923  sizeof(::DataObjectHandleProperty) );
1924  instance.SetDelete(&delete_DataObjectHandleProperty);
1925  instance.SetDeleteArray(&deleteArray_DataObjectHandleProperty);
1926  instance.SetDestructor(&destruct_DataObjectHandleProperty);
1927  return &instance;
1928  }
1929  TGenericClassInfo *GenerateInitInstance(const ::DataObjectHandleProperty*)
1930  {
1931  return GenerateInitInstanceLocal((::DataObjectHandleProperty*)0);
1932  }
1933  // Static variable to force the class initialization
1934  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DataObjectHandleProperty*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1935 
1936  // Dictionary for non-ClassDef classes
1937  static TClass *DataObjectHandleProperty_Dictionary() {
1938  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::DataObjectHandleProperty*)0x0)->GetClass();
1939  DataObjectHandleProperty_TClassManip(theClass);
1940  return theClass;
1941  }
1942 
1943  static void DataObjectHandleProperty_TClassManip(TClass* ){
1944  }
1945 
1946 } // end of namespace ROOT
1947 
1948 namespace ROOT {
1949  static TClass *GaudiHandleInfo_Dictionary();
1950  static void GaudiHandleInfo_TClassManip(TClass*);
1951  static void delete_GaudiHandleInfo(void *p);
1952  static void deleteArray_GaudiHandleInfo(void *p);
1953  static void destruct_GaudiHandleInfo(void *p);
1954 
1955  // Function generating the singleton type initializer
1956  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHandleInfo*)
1957  {
1958  ::GaudiHandleInfo *ptr = 0;
1959  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHandleInfo));
1960  static ::ROOT::TGenericClassInfo
1961  instance("GaudiHandleInfo", "GaudiKernel/GaudiHandle.h", 27,
1962  typeid(::GaudiHandleInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1963  &GaudiHandleInfo_Dictionary, isa_proxy, 4,
1964  sizeof(::GaudiHandleInfo) );
1965  instance.SetDelete(&delete_GaudiHandleInfo);
1966  instance.SetDeleteArray(&deleteArray_GaudiHandleInfo);
1967  instance.SetDestructor(&destruct_GaudiHandleInfo);
1968  return &instance;
1969  }
1970  TGenericClassInfo *GenerateInitInstance(const ::GaudiHandleInfo*)
1971  {
1972  return GenerateInitInstanceLocal((::GaudiHandleInfo*)0);
1973  }
1974  // Static variable to force the class initialization
1975  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHandleInfo*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1976 
1977  // Dictionary for non-ClassDef classes
1978  static TClass *GaudiHandleInfo_Dictionary() {
1979  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHandleInfo*)0x0)->GetClass();
1980  GaudiHandleInfo_TClassManip(theClass);
1981  return theClass;
1982  }
1983 
1984  static void GaudiHandleInfo_TClassManip(TClass* ){
1985  }
1986 
1987 } // end of namespace ROOT
1988 
1989 namespace ROOT {
1990  static TClass *GaudiHandleBase_Dictionary();
1991  static void GaudiHandleBase_TClassManip(TClass*);
1992  static void delete_GaudiHandleBase(void *p);
1993  static void deleteArray_GaudiHandleBase(void *p);
1994  static void destruct_GaudiHandleBase(void *p);
1995 
1996  // Function generating the singleton type initializer
1997  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHandleBase*)
1998  {
1999  ::GaudiHandleBase *ptr = 0;
2000  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHandleBase));
2001  static ::ROOT::TGenericClassInfo
2002  instance("GaudiHandleBase", "GaudiKernel/GaudiHandle.h", 94,
2003  typeid(::GaudiHandleBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2004  &GaudiHandleBase_Dictionary, isa_proxy, 4,
2005  sizeof(::GaudiHandleBase) );
2006  instance.SetDelete(&delete_GaudiHandleBase);
2007  instance.SetDeleteArray(&deleteArray_GaudiHandleBase);
2008  instance.SetDestructor(&destruct_GaudiHandleBase);
2009  return &instance;
2010  }
2011  TGenericClassInfo *GenerateInitInstance(const ::GaudiHandleBase*)
2012  {
2013  return GenerateInitInstanceLocal((::GaudiHandleBase*)0);
2014  }
2015  // Static variable to force the class initialization
2016  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHandleBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2017 
2018  // Dictionary for non-ClassDef classes
2019  static TClass *GaudiHandleBase_Dictionary() {
2020  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHandleBase*)0x0)->GetClass();
2021  GaudiHandleBase_TClassManip(theClass);
2022  return theClass;
2023  }
2024 
2025  static void GaudiHandleBase_TClassManip(TClass* ){
2026  }
2027 
2028 } // end of namespace ROOT
2029 
2030 namespace ROOT {
2031  static TClass *GaudiHandleArrayBase_Dictionary();
2032  static void GaudiHandleArrayBase_TClassManip(TClass*);
2033  static void delete_GaudiHandleArrayBase(void *p);
2034  static void deleteArray_GaudiHandleArrayBase(void *p);
2035  static void destruct_GaudiHandleArrayBase(void *p);
2036 
2037  // Function generating the singleton type initializer
2038  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHandleArrayBase*)
2039  {
2040  ::GaudiHandleArrayBase *ptr = 0;
2041  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHandleArrayBase));
2042  static ::ROOT::TGenericClassInfo
2043  instance("GaudiHandleArrayBase", "GaudiKernel/GaudiHandle.h", 354,
2044  typeid(::GaudiHandleArrayBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2045  &GaudiHandleArrayBase_Dictionary, isa_proxy, 4,
2046  sizeof(::GaudiHandleArrayBase) );
2047  instance.SetDelete(&delete_GaudiHandleArrayBase);
2048  instance.SetDeleteArray(&deleteArray_GaudiHandleArrayBase);
2049  instance.SetDestructor(&destruct_GaudiHandleArrayBase);
2050  return &instance;
2051  }
2052  TGenericClassInfo *GenerateInitInstance(const ::GaudiHandleArrayBase*)
2053  {
2054  return GenerateInitInstanceLocal((::GaudiHandleArrayBase*)0);
2055  }
2056  // Static variable to force the class initialization
2057  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHandleArrayBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2058 
2059  // Dictionary for non-ClassDef classes
2060  static TClass *GaudiHandleArrayBase_Dictionary() {
2061  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHandleArrayBase*)0x0)->GetClass();
2062  GaudiHandleArrayBase_TClassManip(theClass);
2063  return theClass;
2064  }
2065 
2066  static void GaudiHandleArrayBase_TClassManip(TClass* ){
2067  }
2068 
2069 } // end of namespace ROOT
2070 
2071 namespace ROOT {
2072  static TClass *AlgTool_Dictionary();
2073  static void AlgTool_TClassManip(TClass*);
2074  static void delete_AlgTool(void *p);
2075  static void deleteArray_AlgTool(void *p);
2076  static void destruct_AlgTool(void *p);
2077 
2078  // Function generating the singleton type initializer
2079  static TGenericClassInfo *GenerateInitInstanceLocal(const ::AlgTool*)
2080  {
2081  ::AlgTool *ptr = 0;
2082  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AlgTool));
2083  static ::ROOT::TGenericClassInfo
2084  instance("AlgTool", "GaudiKernel/AlgTool.h", 47,
2085  typeid(::AlgTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2086  &AlgTool_Dictionary, isa_proxy, 4,
2087  sizeof(::AlgTool) );
2088  instance.SetDelete(&delete_AlgTool);
2089  instance.SetDeleteArray(&deleteArray_AlgTool);
2090  instance.SetDestructor(&destruct_AlgTool);
2091  return &instance;
2092  }
2093  TGenericClassInfo *GenerateInitInstance(const ::AlgTool*)
2094  {
2095  return GenerateInitInstanceLocal((::AlgTool*)0);
2096  }
2097  // Static variable to force the class initialization
2098  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AlgTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2099 
2100  // Dictionary for non-ClassDef classes
2101  static TClass *AlgTool_Dictionary() {
2102  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AlgTool*)0x0)->GetClass();
2103  AlgTool_TClassManip(theClass);
2104  return theClass;
2105  }
2106 
2107  static void AlgTool_TClassManip(TClass* ){
2108  }
2109 
2110 } // end of namespace ROOT
2111 
2112 namespace ROOT {
2113  static TClass *IAlgorithm_Dictionary();
2114  static void IAlgorithm_TClassManip(TClass*);
2115  static void delete_IAlgorithm(void *p);
2116  static void deleteArray_IAlgorithm(void *p);
2117  static void destruct_IAlgorithm(void *p);
2118 
2119  // Function generating the singleton type initializer
2120  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAlgorithm*)
2121  {
2122  ::IAlgorithm *ptr = 0;
2123  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAlgorithm));
2124  static ::ROOT::TGenericClassInfo
2125  instance("IAlgorithm", "GaudiKernel/IAlgorithm.h", 28,
2126  typeid(::IAlgorithm), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2127  &IAlgorithm_Dictionary, isa_proxy, 4,
2128  sizeof(::IAlgorithm) );
2129  instance.SetDelete(&delete_IAlgorithm);
2130  instance.SetDeleteArray(&deleteArray_IAlgorithm);
2131  instance.SetDestructor(&destruct_IAlgorithm);
2132  return &instance;
2133  }
2134  TGenericClassInfo *GenerateInitInstance(const ::IAlgorithm*)
2135  {
2136  return GenerateInitInstanceLocal((::IAlgorithm*)0);
2137  }
2138  // Static variable to force the class initialization
2139  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAlgorithm*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2140 
2141  // Dictionary for non-ClassDef classes
2142  static TClass *IAlgorithm_Dictionary() {
2143  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAlgorithm*)0x0)->GetClass();
2144  IAlgorithm_TClassManip(theClass);
2145  return theClass;
2146  }
2147 
2148  static void IAlgorithm_TClassManip(TClass* ){
2149  }
2150 
2151 } // end of namespace ROOT
2152 
2153 namespace ROOT {
2154  static TClass *IAlgContextSvc_Dictionary();
2155  static void IAlgContextSvc_TClassManip(TClass*);
2156  static void delete_IAlgContextSvc(void *p);
2157  static void deleteArray_IAlgContextSvc(void *p);
2158  static void destruct_IAlgContextSvc(void *p);
2159 
2160  // Function generating the singleton type initializer
2161  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAlgContextSvc*)
2162  {
2163  ::IAlgContextSvc *ptr = 0;
2164  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAlgContextSvc));
2165  static ::ROOT::TGenericClassInfo
2166  instance("IAlgContextSvc", "GaudiKernel/IAlgContextSvc.h", 23,
2167  typeid(::IAlgContextSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2168  &IAlgContextSvc_Dictionary, isa_proxy, 4,
2169  sizeof(::IAlgContextSvc) );
2170  instance.SetDelete(&delete_IAlgContextSvc);
2171  instance.SetDeleteArray(&deleteArray_IAlgContextSvc);
2172  instance.SetDestructor(&destruct_IAlgContextSvc);
2173  return &instance;
2174  }
2175  TGenericClassInfo *GenerateInitInstance(const ::IAlgContextSvc*)
2176  {
2177  return GenerateInitInstanceLocal((::IAlgContextSvc*)0);
2178  }
2179  // Static variable to force the class initialization
2180  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAlgContextSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2181 
2182  // Dictionary for non-ClassDef classes
2183  static TClass *IAlgContextSvc_Dictionary() {
2184  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAlgContextSvc*)0x0)->GetClass();
2185  IAlgContextSvc_TClassManip(theClass);
2186  return theClass;
2187  }
2188 
2189  static void IAlgContextSvc_TClassManip(TClass* ){
2190  }
2191 
2192 } // end of namespace ROOT
2193 
2194 namespace ROOT {
2195  static TClass *IChronoSvc_Dictionary();
2196  static void IChronoSvc_TClassManip(TClass*);
2197  static void delete_IChronoSvc(void *p);
2198  static void deleteArray_IChronoSvc(void *p);
2199  static void destruct_IChronoSvc(void *p);
2200 
2201  // Function generating the singleton type initializer
2202  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IChronoSvc*)
2203  {
2204  ::IChronoSvc *ptr = 0;
2205  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IChronoSvc));
2206  static ::ROOT::TGenericClassInfo
2207  instance("IChronoSvc", "GaudiKernel/IChronoSvc.h", 31,
2208  typeid(::IChronoSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2209  &IChronoSvc_Dictionary, isa_proxy, 4,
2210  sizeof(::IChronoSvc) );
2211  instance.SetDelete(&delete_IChronoSvc);
2212  instance.SetDeleteArray(&deleteArray_IChronoSvc);
2213  instance.SetDestructor(&destruct_IChronoSvc);
2214  return &instance;
2215  }
2216  TGenericClassInfo *GenerateInitInstance(const ::IChronoSvc*)
2217  {
2218  return GenerateInitInstanceLocal((::IChronoSvc*)0);
2219  }
2220  // Static variable to force the class initialization
2221  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IChronoSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2222 
2223  // Dictionary for non-ClassDef classes
2224  static TClass *IChronoSvc_Dictionary() {
2225  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IChronoSvc*)0x0)->GetClass();
2226  IChronoSvc_TClassManip(theClass);
2227  return theClass;
2228  }
2229 
2230  static void IChronoSvc_TClassManip(TClass* ){
2231  }
2232 
2233 } // end of namespace ROOT
2234 
2235 namespace ROOT {
2236  static TClass *IStatSvc_Dictionary();
2237  static void IStatSvc_TClassManip(TClass*);
2238  static void delete_IStatSvc(void *p);
2239  static void deleteArray_IStatSvc(void *p);
2240  static void destruct_IStatSvc(void *p);
2241 
2242  // Function generating the singleton type initializer
2243  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IStatSvc*)
2244  {
2245  ::IStatSvc *ptr = 0;
2246  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IStatSvc));
2247  static ::ROOT::TGenericClassInfo
2248  instance("IStatSvc", "GaudiKernel/IStatSvc.h", 25,
2249  typeid(::IStatSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2250  &IStatSvc_Dictionary, isa_proxy, 4,
2251  sizeof(::IStatSvc) );
2252  instance.SetDelete(&delete_IStatSvc);
2253  instance.SetDeleteArray(&deleteArray_IStatSvc);
2254  instance.SetDestructor(&destruct_IStatSvc);
2255  return &instance;
2256  }
2257  TGenericClassInfo *GenerateInitInstance(const ::IStatSvc*)
2258  {
2259  return GenerateInitInstanceLocal((::IStatSvc*)0);
2260  }
2261  // Static variable to force the class initialization
2262  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IStatSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2263 
2264  // Dictionary for non-ClassDef classes
2265  static TClass *IStatSvc_Dictionary() {
2266  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IStatSvc*)0x0)->GetClass();
2267  IStatSvc_TClassManip(theClass);
2268  return theClass;
2269  }
2270 
2271  static void IStatSvc_TClassManip(TClass* ){
2272  }
2273 
2274 } // end of namespace ROOT
2275 
2276 namespace ROOT {
2277  static TClass *IChronoStatSvc_Dictionary();
2278  static void IChronoStatSvc_TClassManip(TClass*);
2279  static void delete_IChronoStatSvc(void *p);
2280  static void deleteArray_IChronoStatSvc(void *p);
2281  static void destruct_IChronoStatSvc(void *p);
2282 
2283  // Function generating the singleton type initializer
2284  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IChronoStatSvc*)
2285  {
2286  ::IChronoStatSvc *ptr = 0;
2287  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IChronoStatSvc));
2288  static ::ROOT::TGenericClassInfo
2289  instance("IChronoStatSvc", "GaudiKernel/IChronoStatSvc.h", 33,
2290  typeid(::IChronoStatSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2291  &IChronoStatSvc_Dictionary, isa_proxy, 4,
2292  sizeof(::IChronoStatSvc) );
2293  instance.SetDelete(&delete_IChronoStatSvc);
2294  instance.SetDeleteArray(&deleteArray_IChronoStatSvc);
2295  instance.SetDestructor(&destruct_IChronoStatSvc);
2296  return &instance;
2297  }
2298  TGenericClassInfo *GenerateInitInstance(const ::IChronoStatSvc*)
2299  {
2300  return GenerateInitInstanceLocal((::IChronoStatSvc*)0);
2301  }
2302  // Static variable to force the class initialization
2303  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IChronoStatSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2304 
2305  // Dictionary for non-ClassDef classes
2306  static TClass *IChronoStatSvc_Dictionary() {
2307  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IChronoStatSvc*)0x0)->GetClass();
2308  IChronoStatSvc_TClassManip(theClass);
2309  return theClass;
2310  }
2311 
2312  static void IChronoStatSvc_TClassManip(TClass* ){
2313  }
2314 
2315 } // end of namespace ROOT
2316 
2317 namespace ROOT {
2318  static TClass *IConverter_Dictionary();
2319  static void IConverter_TClassManip(TClass*);
2320  static void delete_IConverter(void *p);
2321  static void deleteArray_IConverter(void *p);
2322  static void destruct_IConverter(void *p);
2323 
2324  // Function generating the singleton type initializer
2325  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IConverter*)
2326  {
2327  ::IConverter *ptr = 0;
2328  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IConverter));
2329  static ::ROOT::TGenericClassInfo
2330  instance("IConverter", "GaudiKernel/IConverter.h", 58,
2331  typeid(::IConverter), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2332  &IConverter_Dictionary, isa_proxy, 4,
2333  sizeof(::IConverter) );
2334  instance.SetDelete(&delete_IConverter);
2335  instance.SetDeleteArray(&deleteArray_IConverter);
2336  instance.SetDestructor(&destruct_IConverter);
2337  return &instance;
2338  }
2339  TGenericClassInfo *GenerateInitInstance(const ::IConverter*)
2340  {
2341  return GenerateInitInstanceLocal((::IConverter*)0);
2342  }
2343  // Static variable to force the class initialization
2344  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IConverter*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2345 
2346  // Dictionary for non-ClassDef classes
2347  static TClass *IConverter_Dictionary() {
2348  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IConverter*)0x0)->GetClass();
2349  IConverter_TClassManip(theClass);
2350  return theClass;
2351  }
2352 
2353  static void IConverter_TClassManip(TClass* ){
2354  }
2355 
2356 } // end of namespace ROOT
2357 
2358 namespace ROOT {
2359  static TClass *IConversionSvc_Dictionary();
2360  static void IConversionSvc_TClassManip(TClass*);
2361  static void delete_IConversionSvc(void *p);
2362  static void deleteArray_IConversionSvc(void *p);
2363  static void destruct_IConversionSvc(void *p);
2364 
2365  // Function generating the singleton type initializer
2366  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IConversionSvc*)
2367  {
2368  ::IConversionSvc *ptr = 0;
2369  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IConversionSvc));
2370  static ::ROOT::TGenericClassInfo
2371  instance("IConversionSvc", "GaudiKernel/IConversionSvc.h", 37,
2372  typeid(::IConversionSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2373  &IConversionSvc_Dictionary, isa_proxy, 4,
2374  sizeof(::IConversionSvc) );
2375  instance.SetDelete(&delete_IConversionSvc);
2376  instance.SetDeleteArray(&deleteArray_IConversionSvc);
2377  instance.SetDestructor(&destruct_IConversionSvc);
2378  return &instance;
2379  }
2380  TGenericClassInfo *GenerateInitInstance(const ::IConversionSvc*)
2381  {
2382  return GenerateInitInstanceLocal((::IConversionSvc*)0);
2383  }
2384  // Static variable to force the class initialization
2385  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IConversionSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2386 
2387  // Dictionary for non-ClassDef classes
2388  static TClass *IConversionSvc_Dictionary() {
2389  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IConversionSvc*)0x0)->GetClass();
2390  IConversionSvc_TClassManip(theClass);
2391  return theClass;
2392  }
2393 
2394  static void IConversionSvc_TClassManip(TClass* ){
2395  }
2396 
2397 } // end of namespace ROOT
2398 
2399 namespace ROOT {
2400  static TClass *IExceptionSvc_Dictionary();
2401  static void IExceptionSvc_TClassManip(TClass*);
2402  static void delete_IExceptionSvc(void *p);
2403  static void deleteArray_IExceptionSvc(void *p);
2404  static void destruct_IExceptionSvc(void *p);
2405 
2406  // Function generating the singleton type initializer
2407  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IExceptionSvc*)
2408  {
2409  ::IExceptionSvc *ptr = 0;
2410  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IExceptionSvc));
2411  static ::ROOT::TGenericClassInfo
2412  instance("IExceptionSvc", "GaudiKernel/IExceptionSvc.h", 24,
2413  typeid(::IExceptionSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2414  &IExceptionSvc_Dictionary, isa_proxy, 4,
2415  sizeof(::IExceptionSvc) );
2416  instance.SetDelete(&delete_IExceptionSvc);
2417  instance.SetDeleteArray(&deleteArray_IExceptionSvc);
2418  instance.SetDestructor(&destruct_IExceptionSvc);
2419  return &instance;
2420  }
2421  TGenericClassInfo *GenerateInitInstance(const ::IExceptionSvc*)
2422  {
2423  return GenerateInitInstanceLocal((::IExceptionSvc*)0);
2424  }
2425  // Static variable to force the class initialization
2426  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IExceptionSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2427 
2428  // Dictionary for non-ClassDef classes
2429  static TClass *IExceptionSvc_Dictionary() {
2430  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IExceptionSvc*)0x0)->GetClass();
2431  IExceptionSvc_TClassManip(theClass);
2432  return theClass;
2433  }
2434 
2435  static void IExceptionSvc_TClassManip(TClass* ){
2436  }
2437 
2438 } // end of namespace ROOT
2439 
2440 namespace ROOT {
2441  static TClass *IHistogramSvc_Dictionary();
2442  static void IHistogramSvc_TClassManip(TClass*);
2443  static void delete_IHistogramSvc(void *p);
2444  static void deleteArray_IHistogramSvc(void *p);
2445  static void destruct_IHistogramSvc(void *p);
2446 
2447  // Function generating the singleton type initializer
2448  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IHistogramSvc*)
2449  {
2450  ::IHistogramSvc *ptr = 0;
2451  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IHistogramSvc));
2452  static ::ROOT::TGenericClassInfo
2453  instance("IHistogramSvc", "GaudiKernel/IHistogramSvc.h", 47,
2454  typeid(::IHistogramSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2455  &IHistogramSvc_Dictionary, isa_proxy, 4,
2456  sizeof(::IHistogramSvc) );
2457  instance.SetDelete(&delete_IHistogramSvc);
2458  instance.SetDeleteArray(&deleteArray_IHistogramSvc);
2459  instance.SetDestructor(&destruct_IHistogramSvc);
2460  return &instance;
2461  }
2462  TGenericClassInfo *GenerateInitInstance(const ::IHistogramSvc*)
2463  {
2464  return GenerateInitInstanceLocal((::IHistogramSvc*)0);
2465  }
2466  // Static variable to force the class initialization
2467  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IHistogramSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2468 
2469  // Dictionary for non-ClassDef classes
2470  static TClass *IHistogramSvc_Dictionary() {
2471  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IHistogramSvc*)0x0)->GetClass();
2472  IHistogramSvc_TClassManip(theClass);
2473  return theClass;
2474  }
2475 
2476  static void IHistogramSvc_TClassManip(TClass* ){
2477  }
2478 
2479 } // end of namespace ROOT
2480 
2481 namespace ROOT {
2482  static TClass *INTupleSvc_Dictionary();
2483  static void INTupleSvc_TClassManip(TClass*);
2484  static void delete_INTupleSvc(void *p);
2485  static void deleteArray_INTupleSvc(void *p);
2486  static void destruct_INTupleSvc(void *p);
2487 
2488  // Function generating the singleton type initializer
2489  static TGenericClassInfo *GenerateInitInstanceLocal(const ::INTupleSvc*)
2490  {
2491  ::INTupleSvc *ptr = 0;
2492  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::INTupleSvc));
2493  static ::ROOT::TGenericClassInfo
2494  instance("INTupleSvc", "GaudiKernel/INTupleSvc.h", 37,
2495  typeid(::INTupleSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2496  &INTupleSvc_Dictionary, isa_proxy, 4,
2497  sizeof(::INTupleSvc) );
2498  instance.SetDelete(&delete_INTupleSvc);
2499  instance.SetDeleteArray(&deleteArray_INTupleSvc);
2500  instance.SetDestructor(&destruct_INTupleSvc);
2501  return &instance;
2502  }
2503  TGenericClassInfo *GenerateInitInstance(const ::INTupleSvc*)
2504  {
2505  return GenerateInitInstanceLocal((::INTupleSvc*)0);
2506  }
2507  // Static variable to force the class initialization
2508  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::INTupleSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2509 
2510  // Dictionary for non-ClassDef classes
2511  static TClass *INTupleSvc_Dictionary() {
2512  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::INTupleSvc*)0x0)->GetClass();
2513  INTupleSvc_TClassManip(theClass);
2514  return theClass;
2515  }
2516 
2517  static void INTupleSvc_TClassManip(TClass* ){
2518  }
2519 
2520 } // end of namespace ROOT
2521 
2522 namespace ROOT {
2523  static TClass *IRndmGen_Dictionary();
2524  static void IRndmGen_TClassManip(TClass*);
2525  static void delete_IRndmGen(void *p);
2526  static void deleteArray_IRndmGen(void *p);
2527  static void destruct_IRndmGen(void *p);
2528 
2529  // Function generating the singleton type initializer
2530  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IRndmGen*)
2531  {
2532  ::IRndmGen *ptr = 0;
2533  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IRndmGen));
2534  static ::ROOT::TGenericClassInfo
2535  instance("IRndmGen", "GaudiKernel/IRndmGen.h", 34,
2536  typeid(::IRndmGen), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2537  &IRndmGen_Dictionary, isa_proxy, 4,
2538  sizeof(::IRndmGen) );
2539  instance.SetDelete(&delete_IRndmGen);
2540  instance.SetDeleteArray(&deleteArray_IRndmGen);
2541  instance.SetDestructor(&destruct_IRndmGen);
2542  return &instance;
2543  }
2544  TGenericClassInfo *GenerateInitInstance(const ::IRndmGen*)
2545  {
2546  return GenerateInitInstanceLocal((::IRndmGen*)0);
2547  }
2548  // Static variable to force the class initialization
2549  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IRndmGen*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2550 
2551  // Dictionary for non-ClassDef classes
2552  static TClass *IRndmGen_Dictionary() {
2553  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IRndmGen*)0x0)->GetClass();
2554  IRndmGen_TClassManip(theClass);
2555  return theClass;
2556  }
2557 
2558  static void IRndmGen_TClassManip(TClass* ){
2559  }
2560 
2561 } // end of namespace ROOT
2562 
2563 namespace ROOT {
2564  static TClass *IRndmGencLcLParam_Dictionary();
2565  static void IRndmGencLcLParam_TClassManip(TClass*);
2566  static void delete_IRndmGencLcLParam(void *p);
2567  static void deleteArray_IRndmGencLcLParam(void *p);
2568  static void destruct_IRndmGencLcLParam(void *p);
2569 
2570  // Function generating the singleton type initializer
2571  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IRndmGen::Param*)
2572  {
2573  ::IRndmGen::Param *ptr = 0;
2574  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IRndmGen::Param));
2575  static ::ROOT::TGenericClassInfo
2576  instance("IRndmGen::Param", "GaudiKernel/IRndmGen.h", 40,
2577  typeid(::IRndmGen::Param), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2578  &IRndmGencLcLParam_Dictionary, isa_proxy, 4,
2579  sizeof(::IRndmGen::Param) );
2580  instance.SetDelete(&delete_IRndmGencLcLParam);
2581  instance.SetDeleteArray(&deleteArray_IRndmGencLcLParam);
2582  instance.SetDestructor(&destruct_IRndmGencLcLParam);
2583  return &instance;
2584  }
2585  TGenericClassInfo *GenerateInitInstance(const ::IRndmGen::Param*)
2586  {
2587  return GenerateInitInstanceLocal((::IRndmGen::Param*)0);
2588  }
2589  // Static variable to force the class initialization
2590  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IRndmGen::Param*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2591 
2592  // Dictionary for non-ClassDef classes
2593  static TClass *IRndmGencLcLParam_Dictionary() {
2594  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IRndmGen::Param*)0x0)->GetClass();
2595  IRndmGencLcLParam_TClassManip(theClass);
2596  return theClass;
2597  }
2598 
2599  static void IRndmGencLcLParam_TClassManip(TClass* ){
2600  }
2601 
2602 } // end of namespace ROOT
2603 
2604 namespace ROOT {
2605  static TClass *IRndmGenSvc_Dictionary();
2606  static void IRndmGenSvc_TClassManip(TClass*);
2607  static void delete_IRndmGenSvc(void *p);
2608  static void deleteArray_IRndmGenSvc(void *p);
2609  static void destruct_IRndmGenSvc(void *p);
2610 
2611  // Function generating the singleton type initializer
2612  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IRndmGenSvc*)
2613  {
2614  ::IRndmGenSvc *ptr = 0;
2615  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IRndmGenSvc));
2616  static ::ROOT::TGenericClassInfo
2617  instance("IRndmGenSvc", "GaudiKernel/IRndmGenSvc.h", 35,
2618  typeid(::IRndmGenSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2619  &IRndmGenSvc_Dictionary, isa_proxy, 4,
2620  sizeof(::IRndmGenSvc) );
2621  instance.SetDelete(&delete_IRndmGenSvc);
2622  instance.SetDeleteArray(&deleteArray_IRndmGenSvc);
2623  instance.SetDestructor(&destruct_IRndmGenSvc);
2624  return &instance;
2625  }
2626  TGenericClassInfo *GenerateInitInstance(const ::IRndmGenSvc*)
2627  {
2628  return GenerateInitInstanceLocal((::IRndmGenSvc*)0);
2629  }
2630  // Static variable to force the class initialization
2631  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IRndmGenSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2632 
2633  // Dictionary for non-ClassDef classes
2634  static TClass *IRndmGenSvc_Dictionary() {
2635  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IRndmGenSvc*)0x0)->GetClass();
2636  IRndmGenSvc_TClassManip(theClass);
2637  return theClass;
2638  }
2639 
2640  static void IRndmGenSvc_TClassManip(TClass* ){
2641  }
2642 
2643 } // end of namespace ROOT
2644 
2645 namespace ROOT {
2646  static TClass *Algorithm_Dictionary();
2647  static void Algorithm_TClassManip(TClass*);
2648  static void delete_Algorithm(void *p);
2649  static void deleteArray_Algorithm(void *p);
2650  static void destruct_Algorithm(void *p);
2651 
2652  // Function generating the singleton type initializer
2653  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Algorithm*)
2654  {
2655  ::Algorithm *ptr = 0;
2656  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Algorithm));
2657  static ::ROOT::TGenericClassInfo
2658  instance("Algorithm", "GaudiKernel/Algorithm.h", 78,
2659  typeid(::Algorithm), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2660  &Algorithm_Dictionary, isa_proxy, 4,
2661  sizeof(::Algorithm) );
2662  instance.SetDelete(&delete_Algorithm);
2663  instance.SetDeleteArray(&deleteArray_Algorithm);
2664  instance.SetDestructor(&destruct_Algorithm);
2665  return &instance;
2666  }
2667  TGenericClassInfo *GenerateInitInstance(const ::Algorithm*)
2668  {
2669  return GenerateInitInstanceLocal((::Algorithm*)0);
2670  }
2671  // Static variable to force the class initialization
2672  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Algorithm*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2673 
2674  // Dictionary for non-ClassDef classes
2675  static TClass *Algorithm_Dictionary() {
2676  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Algorithm*)0x0)->GetClass();
2677  Algorithm_TClassManip(theClass);
2678  return theClass;
2679  }
2680 
2681  static void Algorithm_TClassManip(TClass* ){
2682  }
2683 
2684 } // end of namespace ROOT
2685 
2686 namespace ROOT {
2687  static TClass *DataObject_Dictionary();
2688  static void DataObject_TClassManip(TClass*);
2689  static void *new_DataObject(void *p = 0);
2690  static void *newArray_DataObject(Long_t size, void *p);
2691  static void delete_DataObject(void *p);
2692  static void deleteArray_DataObject(void *p);
2693  static void destruct_DataObject(void *p);
2694 
2695  // Function generating the singleton type initializer
2696  static TGenericClassInfo *GenerateInitInstanceLocal(const ::DataObject*)
2697  {
2698  ::DataObject *ptr = 0;
2699  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::DataObject));
2700  static ::ROOT::TGenericClassInfo
2701  instance("DataObject", "GaudiKernel/DataObject.h", 30,
2702  typeid(::DataObject), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2703  &DataObject_Dictionary, isa_proxy, 4,
2704  sizeof(::DataObject) );
2705  instance.SetNew(&new_DataObject);
2706  instance.SetNewArray(&newArray_DataObject);
2707  instance.SetDelete(&delete_DataObject);
2708  instance.SetDeleteArray(&deleteArray_DataObject);
2709  instance.SetDestructor(&destruct_DataObject);
2710  return &instance;
2711  }
2712  TGenericClassInfo *GenerateInitInstance(const ::DataObject*)
2713  {
2714  return GenerateInitInstanceLocal((::DataObject*)0);
2715  }
2716  // Static variable to force the class initialization
2717  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DataObject*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2718 
2719  // Dictionary for non-ClassDef classes
2720  static TClass *DataObject_Dictionary() {
2721  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::DataObject*)0x0)->GetClass();
2722  DataObject_TClassManip(theClass);
2723  return theClass;
2724  }
2725 
2726  static void DataObject_TClassManip(TClass* theClass){
2727  theClass->CreateAttributeMap();
2728  TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
2729  attrMap->AddProperty("id","00000001-0000-0000-0000-000000000000");
2730  }
2731 
2732 } // end of namespace ROOT
2733 
2734 namespace ROOT {
2735  static TClass *ObjectContainerBase_Dictionary();
2736  static void ObjectContainerBase_TClassManip(TClass*);
2737  static void delete_ObjectContainerBase(void *p);
2738  static void deleteArray_ObjectContainerBase(void *p);
2739  static void destruct_ObjectContainerBase(void *p);
2740 
2741  // Function generating the singleton type initializer
2742  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ObjectContainerBase*)
2743  {
2744  ::ObjectContainerBase *ptr = 0;
2745  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ObjectContainerBase));
2746  static ::ROOT::TGenericClassInfo
2747  instance("ObjectContainerBase", "GaudiKernel/ObjectContainerBase.h", 19,
2748  typeid(::ObjectContainerBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2749  &ObjectContainerBase_Dictionary, isa_proxy, 4,
2750  sizeof(::ObjectContainerBase) );
2751  instance.SetDelete(&delete_ObjectContainerBase);
2752  instance.SetDeleteArray(&deleteArray_ObjectContainerBase);
2753  instance.SetDestructor(&destruct_ObjectContainerBase);
2754  return &instance;
2755  }
2756  TGenericClassInfo *GenerateInitInstance(const ::ObjectContainerBase*)
2757  {
2758  return GenerateInitInstanceLocal((::ObjectContainerBase*)0);
2759  }
2760  // Static variable to force the class initialization
2761  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ObjectContainerBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2762 
2763  // Dictionary for non-ClassDef classes
2764  static TClass *ObjectContainerBase_Dictionary() {
2765  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ObjectContainerBase*)0x0)->GetClass();
2766  ObjectContainerBase_TClassManip(theClass);
2767  return theClass;
2768  }
2769 
2770  static void ObjectContainerBase_TClassManip(TClass* ){
2771  }
2772 
2773 } // end of namespace ROOT
2774 
2775 namespace ROOT {
2776  static TClass *ContainedObject_Dictionary();
2777  static void ContainedObject_TClassManip(TClass*);
2778 
2779  // Function generating the singleton type initializer
2780  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ContainedObject*)
2781  {
2782  ::ContainedObject *ptr = 0;
2783  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ContainedObject));
2784  static ::ROOT::TGenericClassInfo
2785  instance("ContainedObject", "GaudiKernel/ContainedObject.h", 31,
2786  typeid(::ContainedObject), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2787  &ContainedObject_Dictionary, isa_proxy, 4,
2788  sizeof(::ContainedObject) );
2789  return &instance;
2790  }
2791  TGenericClassInfo *GenerateInitInstance(const ::ContainedObject*)
2792  {
2793  return GenerateInitInstanceLocal((::ContainedObject*)0);
2794  }
2795  // Static variable to force the class initialization
2796  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ContainedObject*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2797 
2798  // Dictionary for non-ClassDef classes
2799  static TClass *ContainedObject_Dictionary() {
2800  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ContainedObject*)0x0)->GetClass();
2801  ContainedObject_TClassManip(theClass);
2802  return theClass;
2803  }
2804 
2805  static void ContainedObject_TClassManip(TClass* theClass){
2806  theClass->CreateAttributeMap();
2807  TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
2808  attrMap->AddProperty("id","000000BE-0000-0000-0000-000000000000");
2809  }
2810 
2811 } // end of namespace ROOT
2812 
2813 namespace ROOT {
2814  static TClass *IDataStreamTool_Dictionary();
2815  static void IDataStreamTool_TClassManip(TClass*);
2816  static void delete_IDataStreamTool(void *p);
2817  static void deleteArray_IDataStreamTool(void *p);
2818  static void destruct_IDataStreamTool(void *p);
2819 
2820  // Function generating the singleton type initializer
2821  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDataStreamTool*)
2822  {
2823  ::IDataStreamTool *ptr = 0;
2824  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDataStreamTool));
2825  static ::ROOT::TGenericClassInfo
2826  instance("IDataStreamTool", "GaudiKernel/IDataStreamTool.h", 22,
2827  typeid(::IDataStreamTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2828  &IDataStreamTool_Dictionary, isa_proxy, 4,
2829  sizeof(::IDataStreamTool) );
2830  instance.SetDelete(&delete_IDataStreamTool);
2831  instance.SetDeleteArray(&deleteArray_IDataStreamTool);
2832  instance.SetDestructor(&destruct_IDataStreamTool);
2833  return &instance;
2834  }
2835  TGenericClassInfo *GenerateInitInstance(const ::IDataStreamTool*)
2836  {
2837  return GenerateInitInstanceLocal((::IDataStreamTool*)0);
2838  }
2839  // Static variable to force the class initialization
2840  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDataStreamTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2841 
2842  // Dictionary for non-ClassDef classes
2843  static TClass *IDataStreamTool_Dictionary() {
2844  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDataStreamTool*)0x0)->GetClass();
2845  IDataStreamTool_TClassManip(theClass);
2846  return theClass;
2847  }
2848 
2849  static void IDataStreamTool_TClassManip(TClass* ){
2850  }
2851 
2852 } // end of namespace ROOT
2853 
2854 namespace ROOT {
2855  static TClass *IOpaqueAddress_Dictionary();
2856  static void IOpaqueAddress_TClassManip(TClass*);
2857  static void delete_IOpaqueAddress(void *p);
2858  static void deleteArray_IOpaqueAddress(void *p);
2859  static void destruct_IOpaqueAddress(void *p);
2860 
2861  // Function generating the singleton type initializer
2862  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IOpaqueAddress*)
2863  {
2864  ::IOpaqueAddress *ptr = 0;
2865  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IOpaqueAddress));
2866  static ::ROOT::TGenericClassInfo
2867  instance("IOpaqueAddress", "GaudiKernel/IOpaqueAddress.h", 23,
2868  typeid(::IOpaqueAddress), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2869  &IOpaqueAddress_Dictionary, isa_proxy, 4,
2870  sizeof(::IOpaqueAddress) );
2871  instance.SetDelete(&delete_IOpaqueAddress);
2872  instance.SetDeleteArray(&deleteArray_IOpaqueAddress);
2873  instance.SetDestructor(&destruct_IOpaqueAddress);
2874  return &instance;
2875  }
2876  TGenericClassInfo *GenerateInitInstance(const ::IOpaqueAddress*)
2877  {
2878  return GenerateInitInstanceLocal((::IOpaqueAddress*)0);
2879  }
2880  // Static variable to force the class initialization
2881  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IOpaqueAddress*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2882 
2883  // Dictionary for non-ClassDef classes
2884  static TClass *IOpaqueAddress_Dictionary() {
2885  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IOpaqueAddress*)0x0)->GetClass();
2886  IOpaqueAddress_TClassManip(theClass);
2887  return theClass;
2888  }
2889 
2890  static void IOpaqueAddress_TClassManip(TClass* ){
2891  }
2892 
2893 } // end of namespace ROOT
2894 
2895 namespace ROOT {
2896  static TClass *IEvtSelector_Dictionary();
2897  static void IEvtSelector_TClassManip(TClass*);
2898  static void delete_IEvtSelector(void *p);
2899  static void deleteArray_IEvtSelector(void *p);
2900  static void destruct_IEvtSelector(void *p);
2901 
2902  // Function generating the singleton type initializer
2903  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IEvtSelector*)
2904  {
2905  ::IEvtSelector *ptr = 0;
2906  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IEvtSelector));
2907  static ::ROOT::TGenericClassInfo
2908  instance("IEvtSelector", "GaudiKernel/IEvtSelector.h", 18,
2909  typeid(::IEvtSelector), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2910  &IEvtSelector_Dictionary, isa_proxy, 4,
2911  sizeof(::IEvtSelector) );
2912  instance.SetDelete(&delete_IEvtSelector);
2913  instance.SetDeleteArray(&deleteArray_IEvtSelector);
2914  instance.SetDestructor(&destruct_IEvtSelector);
2915  return &instance;
2916  }
2917  TGenericClassInfo *GenerateInitInstance(const ::IEvtSelector*)
2918  {
2919  return GenerateInitInstanceLocal((::IEvtSelector*)0);
2920  }
2921  // Static variable to force the class initialization
2922  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IEvtSelector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2923 
2924  // Dictionary for non-ClassDef classes
2925  static TClass *IEvtSelector_Dictionary() {
2926  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IEvtSelector*)0x0)->GetClass();
2927  IEvtSelector_TClassManip(theClass);
2928  return theClass;
2929  }
2930 
2931  static void IEvtSelector_TClassManip(TClass* ){
2932  }
2933 
2934 } // end of namespace ROOT
2935 
2936 namespace ROOT {
2937  static TClass *Incident_Dictionary();
2938  static void Incident_TClassManip(TClass*);
2939  static void delete_Incident(void *p);
2940  static void deleteArray_Incident(void *p);
2941  static void destruct_Incident(void *p);
2942 
2943  // Function generating the singleton type initializer
2944  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Incident*)
2945  {
2946  ::Incident *ptr = 0;
2947  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Incident));
2948  static ::ROOT::TGenericClassInfo
2949  instance("Incident", "GaudiKernel/Incident.h", 17,
2950  typeid(::Incident), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2951  &Incident_Dictionary, isa_proxy, 4,
2952  sizeof(::Incident) );
2953  instance.SetDelete(&delete_Incident);
2954  instance.SetDeleteArray(&deleteArray_Incident);
2955  instance.SetDestructor(&destruct_Incident);
2956  return &instance;
2957  }
2958  TGenericClassInfo *GenerateInitInstance(const ::Incident*)
2959  {
2960  return GenerateInitInstanceLocal((::Incident*)0);
2961  }
2962  // Static variable to force the class initialization
2963  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Incident*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2964 
2965  // Dictionary for non-ClassDef classes
2966  static TClass *Incident_Dictionary() {
2967  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Incident*)0x0)->GetClass();
2968  Incident_TClassManip(theClass);
2969  return theClass;
2970  }
2971 
2972  static void Incident_TClassManip(TClass* ){
2973  }
2974 
2975 } // end of namespace ROOT
2976 
2977 namespace ROOT {
2978  static TClass *IIncidentSvc_Dictionary();
2979  static void IIncidentSvc_TClassManip(TClass*);
2980  static void delete_IIncidentSvc(void *p);
2981  static void deleteArray_IIncidentSvc(void *p);
2982  static void destruct_IIncidentSvc(void *p);
2983 
2984  // Function generating the singleton type initializer
2985  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IIncidentSvc*)
2986  {
2987  ::IIncidentSvc *ptr = 0;
2988  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IIncidentSvc));
2989  static ::ROOT::TGenericClassInfo
2990  instance("IIncidentSvc", "GaudiKernel/IIncidentSvc.h", 23,
2991  typeid(::IIncidentSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2992  &IIncidentSvc_Dictionary, isa_proxy, 4,
2993  sizeof(::IIncidentSvc) );
2994  instance.SetDelete(&delete_IIncidentSvc);
2995  instance.SetDeleteArray(&deleteArray_IIncidentSvc);
2996  instance.SetDestructor(&destruct_IIncidentSvc);
2997  return &instance;
2998  }
2999  TGenericClassInfo *GenerateInitInstance(const ::IIncidentSvc*)
3000  {
3001  return GenerateInitInstanceLocal((::IIncidentSvc*)0);
3002  }
3003  // Static variable to force the class initialization
3004  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IIncidentSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3005 
3006  // Dictionary for non-ClassDef classes
3007  static TClass *IIncidentSvc_Dictionary() {
3008  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IIncidentSvc*)0x0)->GetClass();
3009  IIncidentSvc_TClassManip(theClass);
3010  return theClass;
3011  }
3012 
3013  static void IIncidentSvc_TClassManip(TClass* ){
3014  }
3015 
3016 } // end of namespace ROOT
3017 
3018 namespace ROOT {
3019  static TClass *Service_Dictionary();
3020  static void Service_TClassManip(TClass*);
3021 
3022  // Function generating the singleton type initializer
3023  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Service*)
3024  {
3025  ::Service *ptr = 0;
3026  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Service));
3027  static ::ROOT::TGenericClassInfo
3028  instance("Service", "GaudiKernel/Service.h", 36,
3029  typeid(::Service), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3030  &Service_Dictionary, isa_proxy, 4,
3031  sizeof(::Service) );
3032  return &instance;
3033  }
3034  TGenericClassInfo *GenerateInitInstance(const ::Service*)
3035  {
3036  return GenerateInitInstanceLocal((::Service*)0);
3037  }
3038  // Static variable to force the class initialization
3039  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Service*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3040 
3041  // Dictionary for non-ClassDef classes
3042  static TClass *Service_Dictionary() {
3043  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Service*)0x0)->GetClass();
3044  Service_TClassManip(theClass);
3045  return theClass;
3046  }
3047 
3048  static void Service_TClassManip(TClass* ){
3049  }
3050 
3051 } // end of namespace ROOT
3052 
3053 namespace ROOT {
3054  static TClass *GenericAddress_Dictionary();
3055  static void GenericAddress_TClassManip(TClass*);
3056  static void *new_GenericAddress(void *p = 0);
3057  static void *newArray_GenericAddress(Long_t size, void *p);
3058  static void delete_GenericAddress(void *p);
3059  static void deleteArray_GenericAddress(void *p);
3060  static void destruct_GenericAddress(void *p);
3061 
3062  // Function generating the singleton type initializer
3063  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GenericAddress*)
3064  {
3065  ::GenericAddress *ptr = 0;
3066  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GenericAddress));
3067  static ::ROOT::TGenericClassInfo
3068  instance("GenericAddress", "GaudiKernel/GenericAddress.h", 20,
3069  typeid(::GenericAddress), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3070  &GenericAddress_Dictionary, isa_proxy, 4,
3071  sizeof(::GenericAddress) );
3072  instance.SetNew(&new_GenericAddress);
3073  instance.SetNewArray(&newArray_GenericAddress);
3074  instance.SetDelete(&delete_GenericAddress);
3075  instance.SetDeleteArray(&deleteArray_GenericAddress);
3076  instance.SetDestructor(&destruct_GenericAddress);
3077  return &instance;
3078  }
3079  TGenericClassInfo *GenerateInitInstance(const ::GenericAddress*)
3080  {
3081  return GenerateInitInstanceLocal((::GenericAddress*)0);
3082  }
3083  // Static variable to force the class initialization
3084  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GenericAddress*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3085 
3086  // Dictionary for non-ClassDef classes
3087  static TClass *GenericAddress_Dictionary() {
3088  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GenericAddress*)0x0)->GetClass();
3089  GenericAddress_TClassManip(theClass);
3090  return theClass;
3091  }
3092 
3093  static void GenericAddress_TClassManip(TClass* ){
3094  }
3095 
3096 } // end of namespace ROOT
3097 
3098 namespace ROOT {
3099  static TClass *KeyedObjectlEintgR_Dictionary();
3100  static void KeyedObjectlEintgR_TClassManip(TClass*);
3101  static void *new_KeyedObjectlEintgR(void *p = 0);
3102  static void *newArray_KeyedObjectlEintgR(Long_t size, void *p);
3103  static void delete_KeyedObjectlEintgR(void *p);
3104  static void deleteArray_KeyedObjectlEintgR(void *p);
3105  static void destruct_KeyedObjectlEintgR(void *p);
3106 
3107  // Function generating the singleton type initializer
3108  static TGenericClassInfo *GenerateInitInstanceLocal(const ::KeyedObject<int>*)
3109  {
3110  ::KeyedObject<int> *ptr = 0;
3111  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::KeyedObject<int>));
3112  static ::ROOT::TGenericClassInfo
3113  instance("KeyedObject<int>", "GaudiKernel/KeyedObject.h", 30,
3114  typeid(::KeyedObject<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3115  &KeyedObjectlEintgR_Dictionary, isa_proxy, 4,
3116  sizeof(::KeyedObject<int>) );
3117  instance.SetNew(&new_KeyedObjectlEintgR);
3118  instance.SetNewArray(&newArray_KeyedObjectlEintgR);
3119  instance.SetDelete(&delete_KeyedObjectlEintgR);
3120  instance.SetDeleteArray(&deleteArray_KeyedObjectlEintgR);
3121  instance.SetDestructor(&destruct_KeyedObjectlEintgR);
3122  return &instance;
3123  }
3124  TGenericClassInfo *GenerateInitInstance(const ::KeyedObject<int>*)
3125  {
3126  return GenerateInitInstanceLocal((::KeyedObject<int>*)0);
3127  }
3128  // Static variable to force the class initialization
3129  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::KeyedObject<int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3130 
3131  // Dictionary for non-ClassDef classes
3132  static TClass *KeyedObjectlEintgR_Dictionary() {
3133  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::KeyedObject<int>*)0x0)->GetClass();
3134  KeyedObjectlEintgR_TClassManip(theClass);
3135  return theClass;
3136  }
3137 
3138  static void KeyedObjectlEintgR_TClassManip(TClass* ){
3139  }
3140 
3141 } // end of namespace ROOT
3142 
3143 namespace ROOT {
3144  static TClass *KeyedObjectlEunsignedsPintgR_Dictionary();
3145  static void KeyedObjectlEunsignedsPintgR_TClassManip(TClass*);
3146  static void *new_KeyedObjectlEunsignedsPintgR(void *p = 0);
3147  static void *newArray_KeyedObjectlEunsignedsPintgR(Long_t size, void *p);
3148  static void delete_KeyedObjectlEunsignedsPintgR(void *p);
3149  static void deleteArray_KeyedObjectlEunsignedsPintgR(void *p);
3150  static void destruct_KeyedObjectlEunsignedsPintgR(void *p);
3151 
3152  // Function generating the singleton type initializer
3153  static TGenericClassInfo *GenerateInitInstanceLocal(const ::KeyedObject<unsigned int>*)
3154  {
3155  ::KeyedObject<unsigned int> *ptr = 0;
3156  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::KeyedObject<unsigned int>));
3157  static ::ROOT::TGenericClassInfo
3158  instance("KeyedObject<unsigned int>", "GaudiKernel/KeyedObject.h", 30,
3159  typeid(::KeyedObject<unsigned int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3160  &KeyedObjectlEunsignedsPintgR_Dictionary, isa_proxy, 4,
3161  sizeof(::KeyedObject<unsigned int>) );
3162  instance.SetNew(&new_KeyedObjectlEunsignedsPintgR);
3163  instance.SetNewArray(&newArray_KeyedObjectlEunsignedsPintgR);
3164  instance.SetDelete(&delete_KeyedObjectlEunsignedsPintgR);
3165  instance.SetDeleteArray(&deleteArray_KeyedObjectlEunsignedsPintgR);
3166  instance.SetDestructor(&destruct_KeyedObjectlEunsignedsPintgR);
3167  return &instance;
3168  }
3169  TGenericClassInfo *GenerateInitInstance(const ::KeyedObject<unsigned int>*)
3170  {
3171  return GenerateInitInstanceLocal((::KeyedObject<unsigned int>*)0);
3172  }
3173  // Static variable to force the class initialization
3174  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::KeyedObject<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3175 
3176  // Dictionary for non-ClassDef classes
3177  static TClass *KeyedObjectlEunsignedsPintgR_Dictionary() {
3178  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::KeyedObject<unsigned int>*)0x0)->GetClass();
3179  KeyedObjectlEunsignedsPintgR_TClassManip(theClass);
3180  return theClass;
3181  }
3182 
3183  static void KeyedObjectlEunsignedsPintgR_TClassManip(TClass* ){
3184  }
3185 
3186 } // end of namespace ROOT
3187 
3188 namespace ROOT {
3189  static TClass *KeyedObjectlElonggR_Dictionary();
3190  static void KeyedObjectlElonggR_TClassManip(TClass*);
3191  static void *new_KeyedObjectlElonggR(void *p = 0);
3192  static void *newArray_KeyedObjectlElonggR(Long_t size, void *p);
3193  static void delete_KeyedObjectlElonggR(void *p);
3194  static void deleteArray_KeyedObjectlElonggR(void *p);
3195  static void destruct_KeyedObjectlElonggR(void *p);
3196 
3197  // Function generating the singleton type initializer
3198  static TGenericClassInfo *GenerateInitInstanceLocal(const ::KeyedObject<long>*)
3199  {
3200  ::KeyedObject<long> *ptr = 0;
3201  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::KeyedObject<long>));
3202  static ::ROOT::TGenericClassInfo
3203  instance("KeyedObject<long>", "GaudiKernel/KeyedObject.h", 30,
3204  typeid(::KeyedObject<long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3205  &KeyedObjectlElonggR_Dictionary, isa_proxy, 4,
3206  sizeof(::KeyedObject<long>) );
3207  instance.SetNew(&new_KeyedObjectlElonggR);
3208  instance.SetNewArray(&newArray_KeyedObjectlElonggR);
3209  instance.SetDelete(&delete_KeyedObjectlElonggR);
3210  instance.SetDeleteArray(&deleteArray_KeyedObjectlElonggR);
3211  instance.SetDestructor(&destruct_KeyedObjectlElonggR);
3212  return &instance;
3213  }
3214  TGenericClassInfo *GenerateInitInstance(const ::KeyedObject<long>*)
3215  {
3216  return GenerateInitInstanceLocal((::KeyedObject<long>*)0);
3217  }
3218  // Static variable to force the class initialization
3219  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::KeyedObject<long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3220 
3221  // Dictionary for non-ClassDef classes
3222  static TClass *KeyedObjectlElonggR_Dictionary() {
3223  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::KeyedObject<long>*)0x0)->GetClass();
3224  KeyedObjectlElonggR_TClassManip(theClass);
3225  return theClass;
3226  }
3227 
3228  static void KeyedObjectlElonggR_TClassManip(TClass* ){
3229  }
3230 
3231 } // end of namespace ROOT
3232 
3233 namespace ROOT {
3234  static TClass *KeyedObjectlEunsignedsPlonggR_Dictionary();
3235  static void KeyedObjectlEunsignedsPlonggR_TClassManip(TClass*);
3236  static void *new_KeyedObjectlEunsignedsPlonggR(void *p = 0);
3237  static void *newArray_KeyedObjectlEunsignedsPlonggR(Long_t size, void *p);
3238  static void delete_KeyedObjectlEunsignedsPlonggR(void *p);
3239  static void deleteArray_KeyedObjectlEunsignedsPlonggR(void *p);
3240  static void destruct_KeyedObjectlEunsignedsPlonggR(void *p);
3241 
3242  // Function generating the singleton type initializer
3243  static TGenericClassInfo *GenerateInitInstanceLocal(const ::KeyedObject<unsigned long>*)
3244  {
3245  ::KeyedObject<unsigned long> *ptr = 0;
3246  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::KeyedObject<unsigned long>));
3247  static ::ROOT::TGenericClassInfo
3248  instance("KeyedObject<unsigned long>", "GaudiKernel/KeyedObject.h", 30,
3249  typeid(::KeyedObject<unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3250  &KeyedObjectlEunsignedsPlonggR_Dictionary, isa_proxy, 4,
3251  sizeof(::KeyedObject<unsigned long>) );
3252  instance.SetNew(&new_KeyedObjectlEunsignedsPlonggR);
3253  instance.SetNewArray(&newArray_KeyedObjectlEunsignedsPlonggR);
3254  instance.SetDelete(&delete_KeyedObjectlEunsignedsPlonggR);
3255  instance.SetDeleteArray(&deleteArray_KeyedObjectlEunsignedsPlonggR);
3256  instance.SetDestructor(&destruct_KeyedObjectlEunsignedsPlonggR);
3257  return &instance;
3258  }
3259  TGenericClassInfo *GenerateInitInstance(const ::KeyedObject<unsigned long>*)
3260  {
3261  return GenerateInitInstanceLocal((::KeyedObject<unsigned long>*)0);
3262  }
3263  // Static variable to force the class initialization
3264  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::KeyedObject<unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3265 
3266  // Dictionary for non-ClassDef classes
3267  static TClass *KeyedObjectlEunsignedsPlonggR_Dictionary() {
3268  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::KeyedObject<unsigned long>*)0x0)->GetClass();
3269  KeyedObjectlEunsignedsPlonggR_TClassManip(theClass);
3270  return theClass;
3271  }
3272 
3273  static void KeyedObjectlEunsignedsPlonggR_TClassManip(TClass* ){
3274  }
3275 
3276 } // end of namespace ROOT
3277 
3278 namespace ROOT {
3279  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR_Dictionary();
3280  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR_TClassManip(TClass*);
3281  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p = 0);
3282  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(Long_t size, void *p);
3283  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p);
3284  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p);
3285  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p);
3286 
3287  // Function generating the singleton type initializer
3288  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Containers::KeyedObjectManager<Containers::map>*)
3289  {
3290  ::Containers::KeyedObjectManager<Containers::map> *ptr = 0;
3291  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Containers::KeyedObjectManager<Containers::map>));
3292  static ::ROOT::TGenericClassInfo
3293  instance("Containers::KeyedObjectManager<Containers::map>", "GaudiKernel/KeyedObjectManager.h", 46,
3294  typeid(::Containers::KeyedObjectManager<Containers::map>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3295  &ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR_Dictionary, isa_proxy, 4,
3296  sizeof(::Containers::KeyedObjectManager<Containers::map>) );
3297  instance.SetNew(&new_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR);
3298  instance.SetNewArray(&newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR);
3299  instance.SetDelete(&delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR);
3300  instance.SetDeleteArray(&deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR);
3301  instance.SetDestructor(&destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR);
3302  return &instance;
3303  }
3304  TGenericClassInfo *GenerateInitInstance(const ::Containers::KeyedObjectManager<Containers::map>*)
3305  {
3306  return GenerateInitInstanceLocal((::Containers::KeyedObjectManager<Containers::map>*)0);
3307  }
3308  // Static variable to force the class initialization
3309  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::map>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3310 
3311  // Dictionary for non-ClassDef classes
3312  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR_Dictionary() {
3313  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::map>*)0x0)->GetClass();
3314  ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR_TClassManip(theClass);
3315  return theClass;
3316  }
3317 
3318  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR_TClassManip(TClass* ){
3319  }
3320 
3321 } // end of namespace ROOT
3322 
3323 namespace ROOT {
3324  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR_Dictionary();
3325  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR_TClassManip(TClass*);
3326  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p = 0);
3327  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(Long_t size, void *p);
3328  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p);
3329  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p);
3330  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p);
3331 
3332  // Function generating the singleton type initializer
3333  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Containers::KeyedObjectManager<Containers::hashmap>*)
3334  {
3335  ::Containers::KeyedObjectManager<Containers::hashmap> *ptr = 0;
3336  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Containers::KeyedObjectManager<Containers::hashmap>));
3337  static ::ROOT::TGenericClassInfo
3338  instance("Containers::KeyedObjectManager<Containers::hashmap>", "GaudiKernel/KeyedObjectManager.h", 46,
3339  typeid(::Containers::KeyedObjectManager<Containers::hashmap>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3340  &ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR_Dictionary, isa_proxy, 4,
3341  sizeof(::Containers::KeyedObjectManager<Containers::hashmap>) );
3342  instance.SetNew(&new_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR);
3343  instance.SetNewArray(&newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR);
3344  instance.SetDelete(&delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR);
3345  instance.SetDeleteArray(&deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR);
3346  instance.SetDestructor(&destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR);
3347  return &instance;
3348  }
3349  TGenericClassInfo *GenerateInitInstance(const ::Containers::KeyedObjectManager<Containers::hashmap>*)
3350  {
3351  return GenerateInitInstanceLocal((::Containers::KeyedObjectManager<Containers::hashmap>*)0);
3352  }
3353  // Static variable to force the class initialization
3354  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::hashmap>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3355 
3356  // Dictionary for non-ClassDef classes
3357  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR_Dictionary() {
3358  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::hashmap>*)0x0)->GetClass();
3359  ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR_TClassManip(theClass);
3360  return theClass;
3361  }
3362 
3363  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR_TClassManip(TClass* ){
3364  }
3365 
3366 } // end of namespace ROOT
3367 
3368 namespace ROOT {
3369  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR_Dictionary();
3370  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR_TClassManip(TClass*);
3371  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p = 0);
3372  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(Long_t size, void *p);
3373  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p);
3374  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p);
3375  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p);
3376 
3377  // Function generating the singleton type initializer
3378  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Containers::KeyedObjectManager<Containers::vector>*)
3379  {
3380  ::Containers::KeyedObjectManager<Containers::vector> *ptr = 0;
3381  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Containers::KeyedObjectManager<Containers::vector>));
3382  static ::ROOT::TGenericClassInfo
3383  instance("Containers::KeyedObjectManager<Containers::vector>", "GaudiKernel/KeyedObjectManager.h", 46,
3384  typeid(::Containers::KeyedObjectManager<Containers::vector>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3385  &ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR_Dictionary, isa_proxy, 4,
3386  sizeof(::Containers::KeyedObjectManager<Containers::vector>) );
3387  instance.SetNew(&new_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR);
3388  instance.SetNewArray(&newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR);
3389  instance.SetDelete(&delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR);
3390  instance.SetDeleteArray(&deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR);
3391  instance.SetDestructor(&destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR);
3392  return &instance;
3393  }
3394  TGenericClassInfo *GenerateInitInstance(const ::Containers::KeyedObjectManager<Containers::vector>*)
3395  {
3396  return GenerateInitInstanceLocal((::Containers::KeyedObjectManager<Containers::vector>*)0);
3397  }
3398  // Static variable to force the class initialization
3399  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::vector>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3400 
3401  // Dictionary for non-ClassDef classes
3402  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR_Dictionary() {
3403  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::vector>*)0x0)->GetClass();
3404  ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR_TClassManip(theClass);
3405  return theClass;
3406  }
3407 
3408  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR_TClassManip(TClass* ){
3409  }
3410 
3411 } // end of namespace ROOT
3412 
3413 namespace ROOT {
3414  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR_Dictionary();
3415  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR_TClassManip(TClass*);
3416  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p = 0);
3417  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(Long_t size, void *p);
3418  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p);
3419  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p);
3420  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p);
3421 
3422  // Function generating the singleton type initializer
3423  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Containers::KeyedObjectManager<Containers::array>*)
3424  {
3425  ::Containers::KeyedObjectManager<Containers::array> *ptr = 0;
3426  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Containers::KeyedObjectManager<Containers::array>));
3427  static ::ROOT::TGenericClassInfo
3428  instance("Containers::KeyedObjectManager<Containers::array>", "GaudiKernel/KeyedObjectManager.h", 46,
3429  typeid(::Containers::KeyedObjectManager<Containers::array>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3430  &ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR_Dictionary, isa_proxy, 4,
3431  sizeof(::Containers::KeyedObjectManager<Containers::array>) );
3432  instance.SetNew(&new_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR);
3433  instance.SetNewArray(&newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR);
3434  instance.SetDelete(&delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR);
3435  instance.SetDeleteArray(&deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR);
3436  instance.SetDestructor(&destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR);
3437  return &instance;
3438  }
3439  TGenericClassInfo *GenerateInitInstance(const ::Containers::KeyedObjectManager<Containers::array>*)
3440  {
3441  return GenerateInitInstanceLocal((::Containers::KeyedObjectManager<Containers::array>*)0);
3442  }
3443  // Static variable to force the class initialization
3444  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::array>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3445 
3446  // Dictionary for non-ClassDef classes
3447  static TClass *ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR_Dictionary() {
3448  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Containers::KeyedObjectManager<Containers::array>*)0x0)->GetClass();
3449  ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR_TClassManip(theClass);
3450  return theClass;
3451  }
3452 
3453  static void ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR_TClassManip(TClass* ){
3454  }
3455 
3456 } // end of namespace ROOT
3457 
3458 namespace ROOT {
3459  static TClass *LinkManager_Dictionary();
3460  static void LinkManager_TClassManip(TClass*);
3461  static void *new_LinkManager(void *p = 0);
3462  static void *newArray_LinkManager(Long_t size, void *p);
3463  static void delete_LinkManager(void *p);
3464  static void deleteArray_LinkManager(void *p);
3465  static void destruct_LinkManager(void *p);
3466 
3467  // Function generating the singleton type initializer
3468  static TGenericClassInfo *GenerateInitInstanceLocal(const ::LinkManager*)
3469  {
3470  ::LinkManager *ptr = 0;
3471  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::LinkManager));
3472  static ::ROOT::TGenericClassInfo
3473  instance("LinkManager", "GaudiKernel/LinkManager.h", 21,
3474  typeid(::LinkManager), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3475  &LinkManager_Dictionary, isa_proxy, 4,
3476  sizeof(::LinkManager) );
3477  instance.SetNew(&new_LinkManager);
3478  instance.SetNewArray(&newArray_LinkManager);
3479  instance.SetDelete(&delete_LinkManager);
3480  instance.SetDeleteArray(&deleteArray_LinkManager);
3481  instance.SetDestructor(&destruct_LinkManager);
3482  return &instance;
3483  }
3484  TGenericClassInfo *GenerateInitInstance(const ::LinkManager*)
3485  {
3486  return GenerateInitInstanceLocal((::LinkManager*)0);
3487  }
3488  // Static variable to force the class initialization
3489  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::LinkManager*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3490 
3491  // Dictionary for non-ClassDef classes
3492  static TClass *LinkManager_Dictionary() {
3493  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::LinkManager*)0x0)->GetClass();
3494  LinkManager_TClassManip(theClass);
3495  return theClass;
3496  }
3497 
3498  static void LinkManager_TClassManip(TClass* ){
3499  }
3500 
3501 } // end of namespace ROOT
3502 
3503 namespace ROOT {
3504  static TClass *LinkManagercLcLLink_Dictionary();
3505  static void LinkManagercLcLLink_TClassManip(TClass*);
3506  static void *new_LinkManagercLcLLink(void *p = 0);
3507  static void *newArray_LinkManagercLcLLink(Long_t size, void *p);
3508  static void delete_LinkManagercLcLLink(void *p);
3509  static void deleteArray_LinkManagercLcLLink(void *p);
3510  static void destruct_LinkManagercLcLLink(void *p);
3511 
3512  // Function generating the singleton type initializer
3513  static TGenericClassInfo *GenerateInitInstanceLocal(const ::LinkManager::Link*)
3514  {
3515  ::LinkManager::Link *ptr = 0;
3516  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::LinkManager::Link));
3517  static ::ROOT::TGenericClassInfo
3518  instance("LinkManager::Link", "GaudiKernel/LinkManager.h", 32,
3519  typeid(::LinkManager::Link), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3520  &LinkManagercLcLLink_Dictionary, isa_proxy, 4,
3521  sizeof(::LinkManager::Link) );
3522  instance.SetNew(&new_LinkManagercLcLLink);
3523  instance.SetNewArray(&newArray_LinkManagercLcLLink);
3524  instance.SetDelete(&delete_LinkManagercLcLLink);
3525  instance.SetDeleteArray(&deleteArray_LinkManagercLcLLink);
3526  instance.SetDestructor(&destruct_LinkManagercLcLLink);
3527  return &instance;
3528  }
3529  TGenericClassInfo *GenerateInitInstance(const ::LinkManager::Link*)
3530  {
3531  return GenerateInitInstanceLocal((::LinkManager::Link*)0);
3532  }
3533  // Static variable to force the class initialization
3534  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::LinkManager::Link*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3535 
3536  // Dictionary for non-ClassDef classes
3537  static TClass *LinkManagercLcLLink_Dictionary() {
3538  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::LinkManager::Link*)0x0)->GetClass();
3539  LinkManagercLcLLink_TClassManip(theClass);
3540  return theClass;
3541  }
3542 
3543  static void LinkManagercLcLLink_TClassManip(TClass* ){
3544  }
3545 
3546 } // end of namespace ROOT
3547 
3548 namespace ROOT {
3549  static TClass *SmartRefBase_Dictionary();
3550  static void SmartRefBase_TClassManip(TClass*);
3551  static void *new_SmartRefBase(void *p = 0);
3552  static void *newArray_SmartRefBase(Long_t size, void *p);
3553  static void delete_SmartRefBase(void *p);
3554  static void deleteArray_SmartRefBase(void *p);
3555  static void destruct_SmartRefBase(void *p);
3556 
3557  // Function generating the singleton type initializer
3558  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefBase*)
3559  {
3560  ::SmartRefBase *ptr = 0;
3561  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefBase));
3562  static ::ROOT::TGenericClassInfo
3563  instance("SmartRefBase", "GaudiKernel/SmartRefBase.h", 47,
3564  typeid(::SmartRefBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3565  &SmartRefBase_Dictionary, isa_proxy, 4,
3566  sizeof(::SmartRefBase) );
3567  instance.SetNew(&new_SmartRefBase);
3568  instance.SetNewArray(&newArray_SmartRefBase);
3569  instance.SetDelete(&delete_SmartRefBase);
3570  instance.SetDeleteArray(&deleteArray_SmartRefBase);
3571  instance.SetDestructor(&destruct_SmartRefBase);
3572  return &instance;
3573  }
3574  TGenericClassInfo *GenerateInitInstance(const ::SmartRefBase*)
3575  {
3576  return GenerateInitInstanceLocal((::SmartRefBase*)0);
3577  }
3578  // Static variable to force the class initialization
3579  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3580 
3581  // Dictionary for non-ClassDef classes
3582  static TClass *SmartRefBase_Dictionary() {
3583  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefBase*)0x0)->GetClass();
3584  SmartRefBase_TClassManip(theClass);
3585  return theClass;
3586  }
3587 
3588  static void SmartRefBase_TClassManip(TClass* ){
3589  }
3590 
3591 } // end of namespace ROOT
3592 
3593 namespace ROOT {
3594  static TClass *SmartReflEDataObjectgR_Dictionary();
3595  static void SmartReflEDataObjectgR_TClassManip(TClass*);
3596  static void *new_SmartReflEDataObjectgR(void *p = 0);
3597  static void *newArray_SmartReflEDataObjectgR(Long_t size, void *p);
3598  static void delete_SmartReflEDataObjectgR(void *p);
3599  static void deleteArray_SmartReflEDataObjectgR(void *p);
3600  static void destruct_SmartReflEDataObjectgR(void *p);
3601 
3602  // Function generating the singleton type initializer
3603  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<DataObject>*)
3604  {
3605  ::SmartRef<DataObject> *ptr = 0;
3606  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<DataObject>));
3607  static ::ROOT::TGenericClassInfo
3608  instance("SmartRef<DataObject>", "GaudiKernel/SmartRef.h", 66,
3609  typeid(::SmartRef<DataObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3610  &SmartReflEDataObjectgR_Dictionary, isa_proxy, 4,
3611  sizeof(::SmartRef<DataObject>) );
3612  instance.SetNew(&new_SmartReflEDataObjectgR);
3613  instance.SetNewArray(&newArray_SmartReflEDataObjectgR);
3614  instance.SetDelete(&delete_SmartReflEDataObjectgR);
3615  instance.SetDeleteArray(&deleteArray_SmartReflEDataObjectgR);
3616  instance.SetDestructor(&destruct_SmartReflEDataObjectgR);
3617  return &instance;
3618  }
3619  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<DataObject>*)
3620  {
3621  return GenerateInitInstanceLocal((::SmartRef<DataObject>*)0);
3622  }
3623  // Static variable to force the class initialization
3624  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<DataObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3625 
3626  // Dictionary for non-ClassDef classes
3627  static TClass *SmartReflEDataObjectgR_Dictionary() {
3628  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<DataObject>*)0x0)->GetClass();
3629  SmartReflEDataObjectgR_TClassManip(theClass);
3630  return theClass;
3631  }
3632 
3633  static void SmartReflEDataObjectgR_TClassManip(TClass* ){
3634  }
3635 
3636 } // end of namespace ROOT
3637 
3638 namespace ROOT {
3639  static TClass *SmartReflEContainedObjectgR_Dictionary();
3640  static void SmartReflEContainedObjectgR_TClassManip(TClass*);
3641  static void *new_SmartReflEContainedObjectgR(void *p = 0);
3642  static void *newArray_SmartReflEContainedObjectgR(Long_t size, void *p);
3643  static void delete_SmartReflEContainedObjectgR(void *p);
3644  static void deleteArray_SmartReflEContainedObjectgR(void *p);
3645  static void destruct_SmartReflEContainedObjectgR(void *p);
3646 
3647  // Function generating the singleton type initializer
3648  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<ContainedObject>*)
3649  {
3650  ::SmartRef<ContainedObject> *ptr = 0;
3651  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<ContainedObject>));
3652  static ::ROOT::TGenericClassInfo
3653  instance("SmartRef<ContainedObject>", "GaudiKernel/SmartRef.h", 66,
3654  typeid(::SmartRef<ContainedObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3655  &SmartReflEContainedObjectgR_Dictionary, isa_proxy, 4,
3656  sizeof(::SmartRef<ContainedObject>) );
3657  instance.SetNew(&new_SmartReflEContainedObjectgR);
3658  instance.SetNewArray(&newArray_SmartReflEContainedObjectgR);
3659  instance.SetDelete(&delete_SmartReflEContainedObjectgR);
3660  instance.SetDeleteArray(&deleteArray_SmartReflEContainedObjectgR);
3661  instance.SetDestructor(&destruct_SmartReflEContainedObjectgR);
3662  return &instance;
3663  }
3664  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<ContainedObject>*)
3665  {
3666  return GenerateInitInstanceLocal((::SmartRef<ContainedObject>*)0);
3667  }
3668  // Static variable to force the class initialization
3669  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<ContainedObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3670 
3671  // Dictionary for non-ClassDef classes
3672  static TClass *SmartReflEContainedObjectgR_Dictionary() {
3673  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<ContainedObject>*)0x0)->GetClass();
3674  SmartReflEContainedObjectgR_TClassManip(theClass);
3675  return theClass;
3676  }
3677 
3678  static void SmartReflEContainedObjectgR_TClassManip(TClass* ){
3679  }
3680 
3681 } // end of namespace ROOT
3682 
3683 namespace ROOT {
3684  static TClass *SmartReflEObjectContainerBasegR_Dictionary();
3685  static void SmartReflEObjectContainerBasegR_TClassManip(TClass*);
3686  static void *new_SmartReflEObjectContainerBasegR(void *p = 0);
3687  static void *newArray_SmartReflEObjectContainerBasegR(Long_t size, void *p);
3688  static void delete_SmartReflEObjectContainerBasegR(void *p);
3689  static void deleteArray_SmartReflEObjectContainerBasegR(void *p);
3690  static void destruct_SmartReflEObjectContainerBasegR(void *p);
3691 
3692  // Function generating the singleton type initializer
3693  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<ObjectContainerBase>*)
3694  {
3695  ::SmartRef<ObjectContainerBase> *ptr = 0;
3696  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<ObjectContainerBase>));
3697  static ::ROOT::TGenericClassInfo
3698  instance("SmartRef<ObjectContainerBase>", "GaudiKernel/SmartRef.h", 66,
3699  typeid(::SmartRef<ObjectContainerBase>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3700  &SmartReflEObjectContainerBasegR_Dictionary, isa_proxy, 4,
3701  sizeof(::SmartRef<ObjectContainerBase>) );
3702  instance.SetNew(&new_SmartReflEObjectContainerBasegR);
3703  instance.SetNewArray(&newArray_SmartReflEObjectContainerBasegR);
3704  instance.SetDelete(&delete_SmartReflEObjectContainerBasegR);
3705  instance.SetDeleteArray(&deleteArray_SmartReflEObjectContainerBasegR);
3706  instance.SetDestructor(&destruct_SmartReflEObjectContainerBasegR);
3707  return &instance;
3708  }
3709  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<ObjectContainerBase>*)
3710  {
3711  return GenerateInitInstanceLocal((::SmartRef<ObjectContainerBase>*)0);
3712  }
3713  // Static variable to force the class initialization
3714  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<ObjectContainerBase>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3715 
3716  // Dictionary for non-ClassDef classes
3717  static TClass *SmartReflEObjectContainerBasegR_Dictionary() {
3718  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<ObjectContainerBase>*)0x0)->GetClass();
3719  SmartReflEObjectContainerBasegR_TClassManip(theClass);
3720  return theClass;
3721  }
3722 
3723  static void SmartReflEObjectContainerBasegR_TClassManip(TClass* ){
3724  }
3725 
3726 } // end of namespace ROOT
3727 
3728 namespace ROOT {
3729  static TClass *SmartReflEKeyedObjectlEintgRsPgR_Dictionary();
3730  static void SmartReflEKeyedObjectlEintgRsPgR_TClassManip(TClass*);
3731  static void *new_SmartReflEKeyedObjectlEintgRsPgR(void *p = 0);
3732  static void *newArray_SmartReflEKeyedObjectlEintgRsPgR(Long_t size, void *p);
3733  static void delete_SmartReflEKeyedObjectlEintgRsPgR(void *p);
3734  static void deleteArray_SmartReflEKeyedObjectlEintgRsPgR(void *p);
3735  static void destruct_SmartReflEKeyedObjectlEintgRsPgR(void *p);
3736 
3737  // Function generating the singleton type initializer
3738  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<KeyedObject<int> >*)
3739  {
3740  ::SmartRef<KeyedObject<int> > *ptr = 0;
3741  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<KeyedObject<int> >));
3742  static ::ROOT::TGenericClassInfo
3743  instance("SmartRef<KeyedObject<int> >", "GaudiKernel/SmartRef.h", 66,
3744  typeid(::SmartRef<KeyedObject<int> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3745  &SmartReflEKeyedObjectlEintgRsPgR_Dictionary, isa_proxy, 4,
3746  sizeof(::SmartRef<KeyedObject<int> >) );
3747  instance.SetNew(&new_SmartReflEKeyedObjectlEintgRsPgR);
3748  instance.SetNewArray(&newArray_SmartReflEKeyedObjectlEintgRsPgR);
3749  instance.SetDelete(&delete_SmartReflEKeyedObjectlEintgRsPgR);
3750  instance.SetDeleteArray(&deleteArray_SmartReflEKeyedObjectlEintgRsPgR);
3751  instance.SetDestructor(&destruct_SmartReflEKeyedObjectlEintgRsPgR);
3752  return &instance;
3753  }
3754  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<KeyedObject<int> >*)
3755  {
3756  return GenerateInitInstanceLocal((::SmartRef<KeyedObject<int> >*)0);
3757  }
3758  // Static variable to force the class initialization
3759  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<int> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3760 
3761  // Dictionary for non-ClassDef classes
3762  static TClass *SmartReflEKeyedObjectlEintgRsPgR_Dictionary() {
3763  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<int> >*)0x0)->GetClass();
3764  SmartReflEKeyedObjectlEintgRsPgR_TClassManip(theClass);
3765  return theClass;
3766  }
3767 
3768  static void SmartReflEKeyedObjectlEintgRsPgR_TClassManip(TClass* ){
3769  }
3770 
3771 } // end of namespace ROOT
3772 
3773 namespace ROOT {
3774  static TClass *SmartReflEKeyedObjectlEunsignedsPintgRsPgR_Dictionary();
3775  static void SmartReflEKeyedObjectlEunsignedsPintgRsPgR_TClassManip(TClass*);
3776  static void *new_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p = 0);
3777  static void *newArray_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(Long_t size, void *p);
3778  static void delete_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p);
3779  static void deleteArray_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p);
3780  static void destruct_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p);
3781 
3782  // Function generating the singleton type initializer
3783  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<KeyedObject<unsigned int> >*)
3784  {
3785  ::SmartRef<KeyedObject<unsigned int> > *ptr = 0;
3786  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<KeyedObject<unsigned int> >));
3787  static ::ROOT::TGenericClassInfo
3788  instance("SmartRef<KeyedObject<unsigned int> >", "GaudiKernel/SmartRef.h", 66,
3789  typeid(::SmartRef<KeyedObject<unsigned int> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3790  &SmartReflEKeyedObjectlEunsignedsPintgRsPgR_Dictionary, isa_proxy, 4,
3791  sizeof(::SmartRef<KeyedObject<unsigned int> >) );
3792  instance.SetNew(&new_SmartReflEKeyedObjectlEunsignedsPintgRsPgR);
3793  instance.SetNewArray(&newArray_SmartReflEKeyedObjectlEunsignedsPintgRsPgR);
3794  instance.SetDelete(&delete_SmartReflEKeyedObjectlEunsignedsPintgRsPgR);
3795  instance.SetDeleteArray(&deleteArray_SmartReflEKeyedObjectlEunsignedsPintgRsPgR);
3796  instance.SetDestructor(&destruct_SmartReflEKeyedObjectlEunsignedsPintgRsPgR);
3797  return &instance;
3798  }
3799  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<KeyedObject<unsigned int> >*)
3800  {
3801  return GenerateInitInstanceLocal((::SmartRef<KeyedObject<unsigned int> >*)0);
3802  }
3803  // Static variable to force the class initialization
3804  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<unsigned int> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3805 
3806  // Dictionary for non-ClassDef classes
3807  static TClass *SmartReflEKeyedObjectlEunsignedsPintgRsPgR_Dictionary() {
3808  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<unsigned int> >*)0x0)->GetClass();
3809  SmartReflEKeyedObjectlEunsignedsPintgRsPgR_TClassManip(theClass);
3810  return theClass;
3811  }
3812 
3813  static void SmartReflEKeyedObjectlEunsignedsPintgRsPgR_TClassManip(TClass* ){
3814  }
3815 
3816 } // end of namespace ROOT
3817 
3818 namespace ROOT {
3819  static TClass *SmartReflEKeyedObjectlElonggRsPgR_Dictionary();
3820  static void SmartReflEKeyedObjectlElonggRsPgR_TClassManip(TClass*);
3821  static void *new_SmartReflEKeyedObjectlElonggRsPgR(void *p = 0);
3822  static void *newArray_SmartReflEKeyedObjectlElonggRsPgR(Long_t size, void *p);
3823  static void delete_SmartReflEKeyedObjectlElonggRsPgR(void *p);
3824  static void deleteArray_SmartReflEKeyedObjectlElonggRsPgR(void *p);
3825  static void destruct_SmartReflEKeyedObjectlElonggRsPgR(void *p);
3826 
3827  // Function generating the singleton type initializer
3828  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<KeyedObject<long> >*)
3829  {
3830  ::SmartRef<KeyedObject<long> > *ptr = 0;
3831  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<KeyedObject<long> >));
3832  static ::ROOT::TGenericClassInfo
3833  instance("SmartRef<KeyedObject<long> >", "GaudiKernel/SmartRef.h", 66,
3834  typeid(::SmartRef<KeyedObject<long> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3835  &SmartReflEKeyedObjectlElonggRsPgR_Dictionary, isa_proxy, 4,
3836  sizeof(::SmartRef<KeyedObject<long> >) );
3837  instance.SetNew(&new_SmartReflEKeyedObjectlElonggRsPgR);
3838  instance.SetNewArray(&newArray_SmartReflEKeyedObjectlElonggRsPgR);
3839  instance.SetDelete(&delete_SmartReflEKeyedObjectlElonggRsPgR);
3840  instance.SetDeleteArray(&deleteArray_SmartReflEKeyedObjectlElonggRsPgR);
3841  instance.SetDestructor(&destruct_SmartReflEKeyedObjectlElonggRsPgR);
3842  return &instance;
3843  }
3844  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<KeyedObject<long> >*)
3845  {
3846  return GenerateInitInstanceLocal((::SmartRef<KeyedObject<long> >*)0);
3847  }
3848  // Static variable to force the class initialization
3849  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<long> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3850 
3851  // Dictionary for non-ClassDef classes
3852  static TClass *SmartReflEKeyedObjectlElonggRsPgR_Dictionary() {
3853  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<long> >*)0x0)->GetClass();
3854  SmartReflEKeyedObjectlElonggRsPgR_TClassManip(theClass);
3855  return theClass;
3856  }
3857 
3858  static void SmartReflEKeyedObjectlElonggRsPgR_TClassManip(TClass* ){
3859  }
3860 
3861 } // end of namespace ROOT
3862 
3863 namespace ROOT {
3864  static TClass *SmartReflEKeyedObjectlEunsignedsPlonggRsPgR_Dictionary();
3865  static void SmartReflEKeyedObjectlEunsignedsPlonggRsPgR_TClassManip(TClass*);
3866  static void *new_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p = 0);
3867  static void *newArray_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(Long_t size, void *p);
3868  static void delete_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p);
3869  static void deleteArray_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p);
3870  static void destruct_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p);
3871 
3872  // Function generating the singleton type initializer
3873  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRef<KeyedObject<unsigned long> >*)
3874  {
3875  ::SmartRef<KeyedObject<unsigned long> > *ptr = 0;
3876  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRef<KeyedObject<unsigned long> >));
3877  static ::ROOT::TGenericClassInfo
3878  instance("SmartRef<KeyedObject<unsigned long> >", "GaudiKernel/SmartRef.h", 66,
3879  typeid(::SmartRef<KeyedObject<unsigned long> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3880  &SmartReflEKeyedObjectlEunsignedsPlonggRsPgR_Dictionary, isa_proxy, 4,
3881  sizeof(::SmartRef<KeyedObject<unsigned long> >) );
3882  instance.SetNew(&new_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR);
3883  instance.SetNewArray(&newArray_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR);
3884  instance.SetDelete(&delete_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR);
3885  instance.SetDeleteArray(&deleteArray_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR);
3886  instance.SetDestructor(&destruct_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR);
3887  return &instance;
3888  }
3889  TGenericClassInfo *GenerateInitInstance(const ::SmartRef<KeyedObject<unsigned long> >*)
3890  {
3891  return GenerateInitInstanceLocal((::SmartRef<KeyedObject<unsigned long> >*)0);
3892  }
3893  // Static variable to force the class initialization
3894  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<unsigned long> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3895 
3896  // Dictionary for non-ClassDef classes
3897  static TClass *SmartReflEKeyedObjectlEunsignedsPlonggRsPgR_Dictionary() {
3898  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRef<KeyedObject<unsigned long> >*)0x0)->GetClass();
3899  SmartReflEKeyedObjectlEunsignedsPlonggRsPgR_TClassManip(theClass);
3900  return theClass;
3901  }
3902 
3903  static void SmartReflEKeyedObjectlEunsignedsPlonggRsPgR_TClassManip(TClass* ){
3904  }
3905 
3906 } // end of namespace ROOT
3907 
3908 namespace ROOT {
3909  static TClass *INTuple_Dictionary();
3910  static void INTuple_TClassManip(TClass*);
3911  static void delete_INTuple(void *p);
3912  static void deleteArray_INTuple(void *p);
3913  static void destruct_INTuple(void *p);
3914 
3915  // Function generating the singleton type initializer
3916  static TGenericClassInfo *GenerateInitInstanceLocal(const ::INTuple*)
3917  {
3918  ::INTuple *ptr = 0;
3919  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::INTuple));
3920  static ::ROOT::TGenericClassInfo
3921  instance("INTuple", "GaudiKernel/INTuple.h", 82,
3922  typeid(::INTuple), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3923  &INTuple_Dictionary, isa_proxy, 4,
3924  sizeof(::INTuple) );
3925  instance.SetDelete(&delete_INTuple);
3926  instance.SetDeleteArray(&deleteArray_INTuple);
3927  instance.SetDestructor(&destruct_INTuple);
3928  return &instance;
3929  }
3930  TGenericClassInfo *GenerateInitInstance(const ::INTuple*)
3931  {
3932  return GenerateInitInstanceLocal((::INTuple*)0);
3933  }
3934  // Static variable to force the class initialization
3935  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::INTuple*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3936 
3937  // Dictionary for non-ClassDef classes
3938  static TClass *INTuple_Dictionary() {
3939  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::INTuple*)0x0)->GetClass();
3940  INTuple_TClassManip(theClass);
3941  return theClass;
3942  }
3943 
3944  static void INTuple_TClassManip(TClass* ){
3945  }
3946 
3947 } // end of namespace ROOT
3948 
3949 namespace ROOT {
3950  static TClass *SmartDataObjectPtr_Dictionary();
3951  static void SmartDataObjectPtr_TClassManip(TClass*);
3952  static void delete_SmartDataObjectPtr(void *p);
3953  static void deleteArray_SmartDataObjectPtr(void *p);
3954  static void destruct_SmartDataObjectPtr(void *p);
3955 
3956  // Function generating the singleton type initializer
3957  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataObjectPtr*)
3958  {
3959  ::SmartDataObjectPtr *ptr = 0;
3960  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataObjectPtr));
3961  static ::ROOT::TGenericClassInfo
3962  instance("SmartDataObjectPtr", "GaudiKernel/SmartDataObjectPtr.h", 32,
3963  typeid(::SmartDataObjectPtr), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3964  &SmartDataObjectPtr_Dictionary, isa_proxy, 4,
3965  sizeof(::SmartDataObjectPtr) );
3966  instance.SetDelete(&delete_SmartDataObjectPtr);
3967  instance.SetDeleteArray(&deleteArray_SmartDataObjectPtr);
3968  instance.SetDestructor(&destruct_SmartDataObjectPtr);
3969  return &instance;
3970  }
3971  TGenericClassInfo *GenerateInitInstance(const ::SmartDataObjectPtr*)
3972  {
3973  return GenerateInitInstanceLocal((::SmartDataObjectPtr*)0);
3974  }
3975  // Static variable to force the class initialization
3976  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataObjectPtr*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3977 
3978  // Dictionary for non-ClassDef classes
3979  static TClass *SmartDataObjectPtr_Dictionary() {
3980  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataObjectPtr*)0x0)->GetClass();
3981  SmartDataObjectPtr_TClassManip(theClass);
3982  return theClass;
3983  }
3984 
3985  static void SmartDataObjectPtr_TClassManip(TClass* ){
3986  }
3987 
3988 } // end of namespace ROOT
3989 
3990 namespace ROOT {
3991  static TClass *SmartDataObjectPtrcLcLObjectLoader_Dictionary();
3992  static void SmartDataObjectPtrcLcLObjectLoader_TClassManip(TClass*);
3993  static void *new_SmartDataObjectPtrcLcLObjectLoader(void *p = 0);
3994  static void *newArray_SmartDataObjectPtrcLcLObjectLoader(Long_t size, void *p);
3995  static void delete_SmartDataObjectPtrcLcLObjectLoader(void *p);
3996  static void deleteArray_SmartDataObjectPtrcLcLObjectLoader(void *p);
3997  static void destruct_SmartDataObjectPtrcLcLObjectLoader(void *p);
3998 
3999  // Function generating the singleton type initializer
4000  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataObjectPtr::ObjectLoader*)
4001  {
4002  ::SmartDataObjectPtr::ObjectLoader *ptr = 0;
4003  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataObjectPtr::ObjectLoader));
4004  static ::ROOT::TGenericClassInfo
4005  instance("SmartDataObjectPtr::ObjectLoader", "GaudiKernel/SmartDataObjectPtr.h", 37,
4006  typeid(::SmartDataObjectPtr::ObjectLoader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4007  &SmartDataObjectPtrcLcLObjectLoader_Dictionary, isa_proxy, 4,
4008  sizeof(::SmartDataObjectPtr::ObjectLoader) );
4009  instance.SetNew(&new_SmartDataObjectPtrcLcLObjectLoader);
4010  instance.SetNewArray(&newArray_SmartDataObjectPtrcLcLObjectLoader);
4011  instance.SetDelete(&delete_SmartDataObjectPtrcLcLObjectLoader);
4012  instance.SetDeleteArray(&deleteArray_SmartDataObjectPtrcLcLObjectLoader);
4013  instance.SetDestructor(&destruct_SmartDataObjectPtrcLcLObjectLoader);
4014  return &instance;
4015  }
4016  TGenericClassInfo *GenerateInitInstance(const ::SmartDataObjectPtr::ObjectLoader*)
4017  {
4018  return GenerateInitInstanceLocal((::SmartDataObjectPtr::ObjectLoader*)0);
4019  }
4020  // Static variable to force the class initialization
4021  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataObjectPtr::ObjectLoader*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4022 
4023  // Dictionary for non-ClassDef classes
4024  static TClass *SmartDataObjectPtrcLcLObjectLoader_Dictionary() {
4025  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataObjectPtr::ObjectLoader*)0x0)->GetClass();
4026  SmartDataObjectPtrcLcLObjectLoader_TClassManip(theClass);
4027  return theClass;
4028  }
4029 
4030  static void SmartDataObjectPtrcLcLObjectLoader_TClassManip(TClass* ){
4031  }
4032 
4033 } // end of namespace ROOT
4034 
4035 namespace ROOT {
4036  static TClass *SmartDataObjectPtrcLcLObjectFinder_Dictionary();
4037  static void SmartDataObjectPtrcLcLObjectFinder_TClassManip(TClass*);
4038  static void *new_SmartDataObjectPtrcLcLObjectFinder(void *p = 0);
4039  static void *newArray_SmartDataObjectPtrcLcLObjectFinder(Long_t size, void *p);
4040  static void delete_SmartDataObjectPtrcLcLObjectFinder(void *p);
4041  static void deleteArray_SmartDataObjectPtrcLcLObjectFinder(void *p);
4042  static void destruct_SmartDataObjectPtrcLcLObjectFinder(void *p);
4043 
4044  // Function generating the singleton type initializer
4045  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataObjectPtr::ObjectFinder*)
4046  {
4047  ::SmartDataObjectPtr::ObjectFinder *ptr = 0;
4048  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataObjectPtr::ObjectFinder));
4049  static ::ROOT::TGenericClassInfo
4050  instance("SmartDataObjectPtr::ObjectFinder", "GaudiKernel/SmartDataObjectPtr.h", 44,
4051  typeid(::SmartDataObjectPtr::ObjectFinder), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4052  &SmartDataObjectPtrcLcLObjectFinder_Dictionary, isa_proxy, 4,
4053  sizeof(::SmartDataObjectPtr::ObjectFinder) );
4054  instance.SetNew(&new_SmartDataObjectPtrcLcLObjectFinder);
4055  instance.SetNewArray(&newArray_SmartDataObjectPtrcLcLObjectFinder);
4056  instance.SetDelete(&delete_SmartDataObjectPtrcLcLObjectFinder);
4057  instance.SetDeleteArray(&deleteArray_SmartDataObjectPtrcLcLObjectFinder);
4058  instance.SetDestructor(&destruct_SmartDataObjectPtrcLcLObjectFinder);
4059  return &instance;
4060  }
4061  TGenericClassInfo *GenerateInitInstance(const ::SmartDataObjectPtr::ObjectFinder*)
4062  {
4063  return GenerateInitInstanceLocal((::SmartDataObjectPtr::ObjectFinder*)0);
4064  }
4065  // Static variable to force the class initialization
4066  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataObjectPtr::ObjectFinder*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4067 
4068  // Dictionary for non-ClassDef classes
4069  static TClass *SmartDataObjectPtrcLcLObjectFinder_Dictionary() {
4070  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataObjectPtr::ObjectFinder*)0x0)->GetClass();
4071  SmartDataObjectPtrcLcLObjectFinder_TClassManip(theClass);
4072  return theClass;
4073  }
4074 
4075  static void SmartDataObjectPtrcLcLObjectFinder_TClassManip(TClass* ){
4076  }
4077 
4078 } // end of namespace ROOT
4079 
4080 namespace ROOT {
4081  static TClass *SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR_Dictionary();
4082  static void SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR_TClassManip(TClass*);
4083  static void delete_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR(void *p);
4084  static void deleteArray_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR(void *p);
4085  static void destruct_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR(void *p);
4086 
4087  // Function generating the singleton type initializer
4088  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)
4089  {
4090  ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader> *ptr = 0;
4091  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>));
4092  static ::ROOT::TGenericClassInfo
4093  instance("SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>", "GaudiKernel/SmartDataStorePtr.h", 45,
4094  typeid(::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4095  &SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR_Dictionary, isa_proxy, 4,
4096  sizeof(::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>) );
4097  instance.SetDelete(&delete_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR);
4098  instance.SetDeleteArray(&deleteArray_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR);
4099  instance.SetDestructor(&destruct_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR);
4100  return &instance;
4101  }
4102  TGenericClassInfo *GenerateInitInstance(const ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)
4103  {
4104  return GenerateInitInstanceLocal((::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)0);
4105  }
4106  // Static variable to force the class initialization
4107  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4108 
4109  // Dictionary for non-ClassDef classes
4110  static TClass *SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR_Dictionary() {
4111  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)0x0)->GetClass();
4112  SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR_TClassManip(theClass);
4113  return theClass;
4114  }
4115 
4116  static void SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR_TClassManip(TClass* ){
4117  }
4118 
4119 } // end of namespace ROOT
4120 
4121 namespace ROOT {
4122  static TClass *SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR_Dictionary();
4123  static void SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR_TClassManip(TClass*);
4124  static void delete_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR(void *p);
4125  static void deleteArray_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR(void *p);
4126  static void destruct_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR(void *p);
4127 
4128  // Function generating the singleton type initializer
4129  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)
4130  {
4131  ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader> *ptr = 0;
4132  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>));
4133  static ::ROOT::TGenericClassInfo
4134  instance("SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>", "GaudiKernel/SmartDataStorePtr.h", 45,
4135  typeid(::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4136  &SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR_Dictionary, isa_proxy, 4,
4137  sizeof(::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>) );
4138  instance.SetDelete(&delete_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR);
4139  instance.SetDeleteArray(&deleteArray_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR);
4140  instance.SetDestructor(&destruct_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR);
4141  return &instance;
4142  }
4143  TGenericClassInfo *GenerateInitInstance(const ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)
4144  {
4145  return GenerateInitInstanceLocal((::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)0);
4146  }
4147  // Static variable to force the class initialization
4148  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4149 
4150  // Dictionary for non-ClassDef classes
4151  static TClass *SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR_Dictionary() {
4152  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)0x0)->GetClass();
4153  SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR_TClassManip(theClass);
4154  return theClass;
4155  }
4156 
4157  static void SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR_TClassManip(TClass* ){
4158  }
4159 
4160 } // end of namespace ROOT
4161 
4162 namespace ROOT {
4163  static TClass *SmartDataPtrlEDataObjectgR_Dictionary();
4164  static void SmartDataPtrlEDataObjectgR_TClassManip(TClass*);
4165  static void delete_SmartDataPtrlEDataObjectgR(void *p);
4166  static void deleteArray_SmartDataPtrlEDataObjectgR(void *p);
4167  static void destruct_SmartDataPtrlEDataObjectgR(void *p);
4168 
4169  // Function generating the singleton type initializer
4170  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataPtr<DataObject>*)
4171  {
4172  ::SmartDataPtr<DataObject> *ptr = 0;
4173  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataPtr<DataObject>));
4174  static ::ROOT::TGenericClassInfo
4175  instance("SmartDataPtr<DataObject>", "GaudiKernel/SmartDataPtr.h", 47,
4176  typeid(::SmartDataPtr<DataObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4177  &SmartDataPtrlEDataObjectgR_Dictionary, isa_proxy, 4,
4178  sizeof(::SmartDataPtr<DataObject>) );
4179  instance.SetDelete(&delete_SmartDataPtrlEDataObjectgR);
4180  instance.SetDeleteArray(&deleteArray_SmartDataPtrlEDataObjectgR);
4181  instance.SetDestructor(&destruct_SmartDataPtrlEDataObjectgR);
4182  return &instance;
4183  }
4184  TGenericClassInfo *GenerateInitInstance(const ::SmartDataPtr<DataObject>*)
4185  {
4186  return GenerateInitInstanceLocal((::SmartDataPtr<DataObject>*)0);
4187  }
4188  // Static variable to force the class initialization
4189  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataPtr<DataObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4190 
4191  // Dictionary for non-ClassDef classes
4192  static TClass *SmartDataPtrlEDataObjectgR_Dictionary() {
4193  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataPtr<DataObject>*)0x0)->GetClass();
4194  SmartDataPtrlEDataObjectgR_TClassManip(theClass);
4195  return theClass;
4196  }
4197 
4198  static void SmartDataPtrlEDataObjectgR_TClassManip(TClass* ){
4199  }
4200 
4201 } // end of namespace ROOT
4202 
4203 namespace ROOT {
4204  static TClass *SmartDataPtrlEObjectContainerBasegR_Dictionary();
4205  static void SmartDataPtrlEObjectContainerBasegR_TClassManip(TClass*);
4206  static void delete_SmartDataPtrlEObjectContainerBasegR(void *p);
4207  static void deleteArray_SmartDataPtrlEObjectContainerBasegR(void *p);
4208  static void destruct_SmartDataPtrlEObjectContainerBasegR(void *p);
4209 
4210  // Function generating the singleton type initializer
4211  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartDataPtr<ObjectContainerBase>*)
4212  {
4213  ::SmartDataPtr<ObjectContainerBase> *ptr = 0;
4214  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartDataPtr<ObjectContainerBase>));
4215  static ::ROOT::TGenericClassInfo
4216  instance("SmartDataPtr<ObjectContainerBase>", "GaudiKernel/SmartDataPtr.h", 47,
4217  typeid(::SmartDataPtr<ObjectContainerBase>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4218  &SmartDataPtrlEObjectContainerBasegR_Dictionary, isa_proxy, 4,
4219  sizeof(::SmartDataPtr<ObjectContainerBase>) );
4220  instance.SetDelete(&delete_SmartDataPtrlEObjectContainerBasegR);
4221  instance.SetDeleteArray(&deleteArray_SmartDataPtrlEObjectContainerBasegR);
4222  instance.SetDestructor(&destruct_SmartDataPtrlEObjectContainerBasegR);
4223  return &instance;
4224  }
4225  TGenericClassInfo *GenerateInitInstance(const ::SmartDataPtr<ObjectContainerBase>*)
4226  {
4227  return GenerateInitInstanceLocal((::SmartDataPtr<ObjectContainerBase>*)0);
4228  }
4229  // Static variable to force the class initialization
4230  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartDataPtr<ObjectContainerBase>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4231 
4232  // Dictionary for non-ClassDef classes
4233  static TClass *SmartDataPtrlEObjectContainerBasegR_Dictionary() {
4234  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartDataPtr<ObjectContainerBase>*)0x0)->GetClass();
4235  SmartDataPtrlEObjectContainerBasegR_TClassManip(theClass);
4236  return theClass;
4237  }
4238 
4239  static void SmartDataPtrlEObjectContainerBasegR_TClassManip(TClass* ){
4240  }
4241 
4242 } // end of namespace ROOT
4243 
4244 namespace ROOT {
4245  static TClass *NTuplecLcLItemlEchargR_Dictionary();
4246  static void NTuplecLcLItemlEchargR_TClassManip(TClass*);
4247  static void *new_NTuplecLcLItemlEchargR(void *p = 0);
4248  static void *newArray_NTuplecLcLItemlEchargR(Long_t size, void *p);
4249  static void delete_NTuplecLcLItemlEchargR(void *p);
4250  static void deleteArray_NTuplecLcLItemlEchargR(void *p);
4251  static void destruct_NTuplecLcLItemlEchargR(void *p);
4252 
4253  // Function generating the singleton type initializer
4254  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<char>*)
4255  {
4256  ::NTuple::Item<char> *ptr = 0;
4257  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<char>));
4258  static ::ROOT::TGenericClassInfo
4259  instance("NTuple::Item<char>", "GaudiKernel/NTuple.h", 260,
4260  typeid(::NTuple::Item<char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4261  &NTuplecLcLItemlEchargR_Dictionary, isa_proxy, 4,
4262  sizeof(::NTuple::Item<char>) );
4263  instance.SetNew(&new_NTuplecLcLItemlEchargR);
4264  instance.SetNewArray(&newArray_NTuplecLcLItemlEchargR);
4265  instance.SetDelete(&delete_NTuplecLcLItemlEchargR);
4266  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEchargR);
4267  instance.SetDestructor(&destruct_NTuplecLcLItemlEchargR);
4268  return &instance;
4269  }
4270  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<char>*)
4271  {
4272  return GenerateInitInstanceLocal((::NTuple::Item<char>*)0);
4273  }
4274  // Static variable to force the class initialization
4275  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4276 
4277  // Dictionary for non-ClassDef classes
4278  static TClass *NTuplecLcLItemlEchargR_Dictionary() {
4279  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<char>*)0x0)->GetClass();
4280  NTuplecLcLItemlEchargR_TClassManip(theClass);
4281  return theClass;
4282  }
4283 
4284  static void NTuplecLcLItemlEchargR_TClassManip(TClass* ){
4285  }
4286 
4287 } // end of namespace ROOT
4288 
4289 namespace ROOT {
4290  static TClass *NTuplecLcLItemlEunsignedsPchargR_Dictionary();
4291  static void NTuplecLcLItemlEunsignedsPchargR_TClassManip(TClass*);
4292  static void *new_NTuplecLcLItemlEunsignedsPchargR(void *p = 0);
4293  static void *newArray_NTuplecLcLItemlEunsignedsPchargR(Long_t size, void *p);
4294  static void delete_NTuplecLcLItemlEunsignedsPchargR(void *p);
4295  static void deleteArray_NTuplecLcLItemlEunsignedsPchargR(void *p);
4296  static void destruct_NTuplecLcLItemlEunsignedsPchargR(void *p);
4297 
4298  // Function generating the singleton type initializer
4299  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<unsigned char>*)
4300  {
4301  ::NTuple::Item<unsigned char> *ptr = 0;
4302  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<unsigned char>));
4303  static ::ROOT::TGenericClassInfo
4304  instance("NTuple::Item<unsigned char>", "GaudiKernel/NTuple.h", 260,
4305  typeid(::NTuple::Item<unsigned char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4306  &NTuplecLcLItemlEunsignedsPchargR_Dictionary, isa_proxy, 4,
4307  sizeof(::NTuple::Item<unsigned char>) );
4308  instance.SetNew(&new_NTuplecLcLItemlEunsignedsPchargR);
4309  instance.SetNewArray(&newArray_NTuplecLcLItemlEunsignedsPchargR);
4310  instance.SetDelete(&delete_NTuplecLcLItemlEunsignedsPchargR);
4311  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEunsignedsPchargR);
4312  instance.SetDestructor(&destruct_NTuplecLcLItemlEunsignedsPchargR);
4313  return &instance;
4314  }
4315  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<unsigned char>*)
4316  {
4317  return GenerateInitInstanceLocal((::NTuple::Item<unsigned char>*)0);
4318  }
4319  // Static variable to force the class initialization
4320  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<unsigned char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4321 
4322  // Dictionary for non-ClassDef classes
4323  static TClass *NTuplecLcLItemlEunsignedsPchargR_Dictionary() {
4324  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<unsigned char>*)0x0)->GetClass();
4325  NTuplecLcLItemlEunsignedsPchargR_TClassManip(theClass);
4326  return theClass;
4327  }
4328 
4329  static void NTuplecLcLItemlEunsignedsPchargR_TClassManip(TClass* ){
4330  }
4331 
4332 } // end of namespace ROOT
4333 
4334 namespace ROOT {
4335  static TClass *NTuplecLcLItemlEshortgR_Dictionary();
4336  static void NTuplecLcLItemlEshortgR_TClassManip(TClass*);
4337  static void *new_NTuplecLcLItemlEshortgR(void *p = 0);
4338  static void *newArray_NTuplecLcLItemlEshortgR(Long_t size, void *p);
4339  static void delete_NTuplecLcLItemlEshortgR(void *p);
4340  static void deleteArray_NTuplecLcLItemlEshortgR(void *p);
4341  static void destruct_NTuplecLcLItemlEshortgR(void *p);
4342 
4343  // Function generating the singleton type initializer
4344  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<short>*)
4345  {
4346  ::NTuple::Item<short> *ptr = 0;
4347  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<short>));
4348  static ::ROOT::TGenericClassInfo
4349  instance("NTuple::Item<short>", "GaudiKernel/NTuple.h", 260,
4350  typeid(::NTuple::Item<short>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4351  &NTuplecLcLItemlEshortgR_Dictionary, isa_proxy, 4,
4352  sizeof(::NTuple::Item<short>) );
4353  instance.SetNew(&new_NTuplecLcLItemlEshortgR);
4354  instance.SetNewArray(&newArray_NTuplecLcLItemlEshortgR);
4355  instance.SetDelete(&delete_NTuplecLcLItemlEshortgR);
4356  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEshortgR);
4357  instance.SetDestructor(&destruct_NTuplecLcLItemlEshortgR);
4358  return &instance;
4359  }
4360  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<short>*)
4361  {
4362  return GenerateInitInstanceLocal((::NTuple::Item<short>*)0);
4363  }
4364  // Static variable to force the class initialization
4365  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<short>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4366 
4367  // Dictionary for non-ClassDef classes
4368  static TClass *NTuplecLcLItemlEshortgR_Dictionary() {
4369  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<short>*)0x0)->GetClass();
4370  NTuplecLcLItemlEshortgR_TClassManip(theClass);
4371  return theClass;
4372  }
4373 
4374  static void NTuplecLcLItemlEshortgR_TClassManip(TClass* ){
4375  }
4376 
4377 } // end of namespace ROOT
4378 
4379 namespace ROOT {
4380  static TClass *NTuplecLcLItemlEunsignedsPshortgR_Dictionary();
4381  static void NTuplecLcLItemlEunsignedsPshortgR_TClassManip(TClass*);
4382  static void *new_NTuplecLcLItemlEunsignedsPshortgR(void *p = 0);
4383  static void *newArray_NTuplecLcLItemlEunsignedsPshortgR(Long_t size, void *p);
4384  static void delete_NTuplecLcLItemlEunsignedsPshortgR(void *p);
4385  static void deleteArray_NTuplecLcLItemlEunsignedsPshortgR(void *p);
4386  static void destruct_NTuplecLcLItemlEunsignedsPshortgR(void *p);
4387 
4388  // Function generating the singleton type initializer
4389  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<unsigned short>*)
4390  {
4391  ::NTuple::Item<unsigned short> *ptr = 0;
4392  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<unsigned short>));
4393  static ::ROOT::TGenericClassInfo
4394  instance("NTuple::Item<unsigned short>", "GaudiKernel/NTuple.h", 260,
4395  typeid(::NTuple::Item<unsigned short>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4396  &NTuplecLcLItemlEunsignedsPshortgR_Dictionary, isa_proxy, 4,
4397  sizeof(::NTuple::Item<unsigned short>) );
4398  instance.SetNew(&new_NTuplecLcLItemlEunsignedsPshortgR);
4399  instance.SetNewArray(&newArray_NTuplecLcLItemlEunsignedsPshortgR);
4400  instance.SetDelete(&delete_NTuplecLcLItemlEunsignedsPshortgR);
4401  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEunsignedsPshortgR);
4402  instance.SetDestructor(&destruct_NTuplecLcLItemlEunsignedsPshortgR);
4403  return &instance;
4404  }
4405  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<unsigned short>*)
4406  {
4407  return GenerateInitInstanceLocal((::NTuple::Item<unsigned short>*)0);
4408  }
4409  // Static variable to force the class initialization
4410  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<unsigned short>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4411 
4412  // Dictionary for non-ClassDef classes
4413  static TClass *NTuplecLcLItemlEunsignedsPshortgR_Dictionary() {
4414  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<unsigned short>*)0x0)->GetClass();
4415  NTuplecLcLItemlEunsignedsPshortgR_TClassManip(theClass);
4416  return theClass;
4417  }
4418 
4419  static void NTuplecLcLItemlEunsignedsPshortgR_TClassManip(TClass* ){
4420  }
4421 
4422 } // end of namespace ROOT
4423 
4424 namespace ROOT {
4425  static TClass *NTuplecLcLItemlElonggR_Dictionary();
4426  static void NTuplecLcLItemlElonggR_TClassManip(TClass*);
4427  static void *new_NTuplecLcLItemlElonggR(void *p = 0);
4428  static void *newArray_NTuplecLcLItemlElonggR(Long_t size, void *p);
4429  static void delete_NTuplecLcLItemlElonggR(void *p);
4430  static void deleteArray_NTuplecLcLItemlElonggR(void *p);
4431  static void destruct_NTuplecLcLItemlElonggR(void *p);
4432 
4433  // Function generating the singleton type initializer
4434  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<long>*)
4435  {
4436  ::NTuple::Item<long> *ptr = 0;
4437  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<long>));
4438  static ::ROOT::TGenericClassInfo
4439  instance("NTuple::Item<long>", "GaudiKernel/NTuple.h", 260,
4440  typeid(::NTuple::Item<long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4441  &NTuplecLcLItemlElonggR_Dictionary, isa_proxy, 4,
4442  sizeof(::NTuple::Item<long>) );
4443  instance.SetNew(&new_NTuplecLcLItemlElonggR);
4444  instance.SetNewArray(&newArray_NTuplecLcLItemlElonggR);
4445  instance.SetDelete(&delete_NTuplecLcLItemlElonggR);
4446  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlElonggR);
4447  instance.SetDestructor(&destruct_NTuplecLcLItemlElonggR);
4448  return &instance;
4449  }
4450  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<long>*)
4451  {
4452  return GenerateInitInstanceLocal((::NTuple::Item<long>*)0);
4453  }
4454  // Static variable to force the class initialization
4455  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4456 
4457  // Dictionary for non-ClassDef classes
4458  static TClass *NTuplecLcLItemlElonggR_Dictionary() {
4459  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<long>*)0x0)->GetClass();
4460  NTuplecLcLItemlElonggR_TClassManip(theClass);
4461  return theClass;
4462  }
4463 
4464  static void NTuplecLcLItemlElonggR_TClassManip(TClass* ){
4465  }
4466 
4467 } // end of namespace ROOT
4468 
4469 namespace ROOT {
4470  static TClass *NTuplecLcLItemlELong64_tgR_Dictionary();
4471  static void NTuplecLcLItemlELong64_tgR_TClassManip(TClass*);
4472  static void *new_NTuplecLcLItemlELong64_tgR(void *p = 0);
4473  static void *newArray_NTuplecLcLItemlELong64_tgR(Long_t size, void *p);
4474  static void delete_NTuplecLcLItemlELong64_tgR(void *p);
4475  static void deleteArray_NTuplecLcLItemlELong64_tgR(void *p);
4476  static void destruct_NTuplecLcLItemlELong64_tgR(void *p);
4477 
4478  // Function generating the singleton type initializer
4479  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<Long64_t>*)
4480  {
4481  ::NTuple::Item<Long64_t> *ptr = 0;
4482  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<Long64_t>));
4483  static ::ROOT::TGenericClassInfo
4484  instance("NTuple::Item<Long64_t>", "GaudiKernel/NTuple.h", 260,
4485  typeid(::NTuple::Item<Long64_t>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4486  &NTuplecLcLItemlELong64_tgR_Dictionary, isa_proxy, 4,
4487  sizeof(::NTuple::Item<Long64_t>) );
4488  instance.SetNew(&new_NTuplecLcLItemlELong64_tgR);
4489  instance.SetNewArray(&newArray_NTuplecLcLItemlELong64_tgR);
4490  instance.SetDelete(&delete_NTuplecLcLItemlELong64_tgR);
4491  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlELong64_tgR);
4492  instance.SetDestructor(&destruct_NTuplecLcLItemlELong64_tgR);
4493  return &instance;
4494  }
4495  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<Long64_t>*)
4496  {
4497  return GenerateInitInstanceLocal((::NTuple::Item<Long64_t>*)0);
4498  }
4499  // Static variable to force the class initialization
4500  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<Long64_t>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4501 
4502  // Dictionary for non-ClassDef classes
4503  static TClass *NTuplecLcLItemlELong64_tgR_Dictionary() {
4504  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<Long64_t>*)0x0)->GetClass();
4505  NTuplecLcLItemlELong64_tgR_TClassManip(theClass);
4506  return theClass;
4507  }
4508 
4509  static void NTuplecLcLItemlELong64_tgR_TClassManip(TClass* ){
4510  }
4511 
4512 } // end of namespace ROOT
4513 
4514 namespace ROOT {
4515  static TClass *NTuplecLcLItemlEunsignedsPlonggR_Dictionary();
4516  static void NTuplecLcLItemlEunsignedsPlonggR_TClassManip(TClass*);
4517  static void *new_NTuplecLcLItemlEunsignedsPlonggR(void *p = 0);
4518  static void *newArray_NTuplecLcLItemlEunsignedsPlonggR(Long_t size, void *p);
4519  static void delete_NTuplecLcLItemlEunsignedsPlonggR(void *p);
4520  static void deleteArray_NTuplecLcLItemlEunsignedsPlonggR(void *p);
4521  static void destruct_NTuplecLcLItemlEunsignedsPlonggR(void *p);
4522 
4523  // Function generating the singleton type initializer
4524  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<unsigned long>*)
4525  {
4526  ::NTuple::Item<unsigned long> *ptr = 0;
4527  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<unsigned long>));
4528  static ::ROOT::TGenericClassInfo
4529  instance("NTuple::Item<unsigned long>", "GaudiKernel/NTuple.h", 260,
4530  typeid(::NTuple::Item<unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4531  &NTuplecLcLItemlEunsignedsPlonggR_Dictionary, isa_proxy, 4,
4532  sizeof(::NTuple::Item<unsigned long>) );
4533  instance.SetNew(&new_NTuplecLcLItemlEunsignedsPlonggR);
4534  instance.SetNewArray(&newArray_NTuplecLcLItemlEunsignedsPlonggR);
4535  instance.SetDelete(&delete_NTuplecLcLItemlEunsignedsPlonggR);
4536  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEunsignedsPlonggR);
4537  instance.SetDestructor(&destruct_NTuplecLcLItemlEunsignedsPlonggR);
4538  return &instance;
4539  }
4540  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<unsigned long>*)
4541  {
4542  return GenerateInitInstanceLocal((::NTuple::Item<unsigned long>*)0);
4543  }
4544  // Static variable to force the class initialization
4545  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4546 
4547  // Dictionary for non-ClassDef classes
4548  static TClass *NTuplecLcLItemlEunsignedsPlonggR_Dictionary() {
4549  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<unsigned long>*)0x0)->GetClass();
4550  NTuplecLcLItemlEunsignedsPlonggR_TClassManip(theClass);
4551  return theClass;
4552  }
4553 
4554  static void NTuplecLcLItemlEunsignedsPlonggR_TClassManip(TClass* ){
4555  }
4556 
4557 } // end of namespace ROOT
4558 
4559 namespace ROOT {
4560  static TClass *NTuplecLcLItemlEULong64_tgR_Dictionary();
4561  static void NTuplecLcLItemlEULong64_tgR_TClassManip(TClass*);
4562  static void *new_NTuplecLcLItemlEULong64_tgR(void *p = 0);
4563  static void *newArray_NTuplecLcLItemlEULong64_tgR(Long_t size, void *p);
4564  static void delete_NTuplecLcLItemlEULong64_tgR(void *p);
4565  static void deleteArray_NTuplecLcLItemlEULong64_tgR(void *p);
4566  static void destruct_NTuplecLcLItemlEULong64_tgR(void *p);
4567 
4568  // Function generating the singleton type initializer
4569  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<ULong64_t>*)
4570  {
4571  ::NTuple::Item<ULong64_t> *ptr = 0;
4572  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<ULong64_t>));
4573  static ::ROOT::TGenericClassInfo
4574  instance("NTuple::Item<ULong64_t>", "GaudiKernel/NTuple.h", 260,
4575  typeid(::NTuple::Item<ULong64_t>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4576  &NTuplecLcLItemlEULong64_tgR_Dictionary, isa_proxy, 4,
4577  sizeof(::NTuple::Item<ULong64_t>) );
4578  instance.SetNew(&new_NTuplecLcLItemlEULong64_tgR);
4579  instance.SetNewArray(&newArray_NTuplecLcLItemlEULong64_tgR);
4580  instance.SetDelete(&delete_NTuplecLcLItemlEULong64_tgR);
4581  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEULong64_tgR);
4582  instance.SetDestructor(&destruct_NTuplecLcLItemlEULong64_tgR);
4583  return &instance;
4584  }
4585  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<ULong64_t>*)
4586  {
4587  return GenerateInitInstanceLocal((::NTuple::Item<ULong64_t>*)0);
4588  }
4589  // Static variable to force the class initialization
4590  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<ULong64_t>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4591 
4592  // Dictionary for non-ClassDef classes
4593  static TClass *NTuplecLcLItemlEULong64_tgR_Dictionary() {
4594  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<ULong64_t>*)0x0)->GetClass();
4595  NTuplecLcLItemlEULong64_tgR_TClassManip(theClass);
4596  return theClass;
4597  }
4598 
4599  static void NTuplecLcLItemlEULong64_tgR_TClassManip(TClass* ){
4600  }
4601 
4602 } // end of namespace ROOT
4603 
4604 namespace ROOT {
4605  static TClass *NTuplecLcLItemlEintgR_Dictionary();
4606  static void NTuplecLcLItemlEintgR_TClassManip(TClass*);
4607  static void *new_NTuplecLcLItemlEintgR(void *p = 0);
4608  static void *newArray_NTuplecLcLItemlEintgR(Long_t size, void *p);
4609  static void delete_NTuplecLcLItemlEintgR(void *p);
4610  static void deleteArray_NTuplecLcLItemlEintgR(void *p);
4611  static void destruct_NTuplecLcLItemlEintgR(void *p);
4612 
4613  // Function generating the singleton type initializer
4614  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<int>*)
4615  {
4616  ::NTuple::Item<int> *ptr = 0;
4617  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<int>));
4618  static ::ROOT::TGenericClassInfo
4619  instance("NTuple::Item<int>", "GaudiKernel/NTuple.h", 260,
4620  typeid(::NTuple::Item<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4621  &NTuplecLcLItemlEintgR_Dictionary, isa_proxy, 4,
4622  sizeof(::NTuple::Item<int>) );
4623  instance.SetNew(&new_NTuplecLcLItemlEintgR);
4624  instance.SetNewArray(&newArray_NTuplecLcLItemlEintgR);
4625  instance.SetDelete(&delete_NTuplecLcLItemlEintgR);
4626  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEintgR);
4627  instance.SetDestructor(&destruct_NTuplecLcLItemlEintgR);
4628  return &instance;
4629  }
4630  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<int>*)
4631  {
4632  return GenerateInitInstanceLocal((::NTuple::Item<int>*)0);
4633  }
4634  // Static variable to force the class initialization
4635  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4636 
4637  // Dictionary for non-ClassDef classes
4638  static TClass *NTuplecLcLItemlEintgR_Dictionary() {
4639  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<int>*)0x0)->GetClass();
4640  NTuplecLcLItemlEintgR_TClassManip(theClass);
4641  return theClass;
4642  }
4643 
4644  static void NTuplecLcLItemlEintgR_TClassManip(TClass* ){
4645  }
4646 
4647 } // end of namespace ROOT
4648 
4649 namespace ROOT {
4650  static TClass *NTuplecLcLItemlEunsignedsPintgR_Dictionary();
4651  static void NTuplecLcLItemlEunsignedsPintgR_TClassManip(TClass*);
4652  static void *new_NTuplecLcLItemlEunsignedsPintgR(void *p = 0);
4653  static void *newArray_NTuplecLcLItemlEunsignedsPintgR(Long_t size, void *p);
4654  static void delete_NTuplecLcLItemlEunsignedsPintgR(void *p);
4655  static void deleteArray_NTuplecLcLItemlEunsignedsPintgR(void *p);
4656  static void destruct_NTuplecLcLItemlEunsignedsPintgR(void *p);
4657 
4658  // Function generating the singleton type initializer
4659  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<unsigned int>*)
4660  {
4661  ::NTuple::Item<unsigned int> *ptr = 0;
4662  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<unsigned int>));
4663  static ::ROOT::TGenericClassInfo
4664  instance("NTuple::Item<unsigned int>", "GaudiKernel/NTuple.h", 260,
4665  typeid(::NTuple::Item<unsigned int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4666  &NTuplecLcLItemlEunsignedsPintgR_Dictionary, isa_proxy, 4,
4667  sizeof(::NTuple::Item<unsigned int>) );
4668  instance.SetNew(&new_NTuplecLcLItemlEunsignedsPintgR);
4669  instance.SetNewArray(&newArray_NTuplecLcLItemlEunsignedsPintgR);
4670  instance.SetDelete(&delete_NTuplecLcLItemlEunsignedsPintgR);
4671  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEunsignedsPintgR);
4672  instance.SetDestructor(&destruct_NTuplecLcLItemlEunsignedsPintgR);
4673  return &instance;
4674  }
4675  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<unsigned int>*)
4676  {
4677  return GenerateInitInstanceLocal((::NTuple::Item<unsigned int>*)0);
4678  }
4679  // Static variable to force the class initialization
4680  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4681 
4682  // Dictionary for non-ClassDef classes
4683  static TClass *NTuplecLcLItemlEunsignedsPintgR_Dictionary() {
4684  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<unsigned int>*)0x0)->GetClass();
4685  NTuplecLcLItemlEunsignedsPintgR_TClassManip(theClass);
4686  return theClass;
4687  }
4688 
4689  static void NTuplecLcLItemlEunsignedsPintgR_TClassManip(TClass* ){
4690  }
4691 
4692 } // end of namespace ROOT
4693 
4694 namespace ROOT {
4695  static TClass *NTuplecLcLItemlEfloatgR_Dictionary();
4696  static void NTuplecLcLItemlEfloatgR_TClassManip(TClass*);
4697  static void *new_NTuplecLcLItemlEfloatgR(void *p = 0);
4698  static void *newArray_NTuplecLcLItemlEfloatgR(Long_t size, void *p);
4699  static void delete_NTuplecLcLItemlEfloatgR(void *p);
4700  static void deleteArray_NTuplecLcLItemlEfloatgR(void *p);
4701  static void destruct_NTuplecLcLItemlEfloatgR(void *p);
4702 
4703  // Function generating the singleton type initializer
4704  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<float>*)
4705  {
4706  ::NTuple::Item<float> *ptr = 0;
4707  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<float>));
4708  static ::ROOT::TGenericClassInfo
4709  instance("NTuple::Item<float>", "GaudiKernel/NTuple.h", 260,
4710  typeid(::NTuple::Item<float>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4711  &NTuplecLcLItemlEfloatgR_Dictionary, isa_proxy, 4,
4712  sizeof(::NTuple::Item<float>) );
4713  instance.SetNew(&new_NTuplecLcLItemlEfloatgR);
4714  instance.SetNewArray(&newArray_NTuplecLcLItemlEfloatgR);
4715  instance.SetDelete(&delete_NTuplecLcLItemlEfloatgR);
4716  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEfloatgR);
4717  instance.SetDestructor(&destruct_NTuplecLcLItemlEfloatgR);
4718  return &instance;
4719  }
4720  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<float>*)
4721  {
4722  return GenerateInitInstanceLocal((::NTuple::Item<float>*)0);
4723  }
4724  // Static variable to force the class initialization
4725  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<float>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4726 
4727  // Dictionary for non-ClassDef classes
4728  static TClass *NTuplecLcLItemlEfloatgR_Dictionary() {
4729  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<float>*)0x0)->GetClass();
4730  NTuplecLcLItemlEfloatgR_TClassManip(theClass);
4731  return theClass;
4732  }
4733 
4734  static void NTuplecLcLItemlEfloatgR_TClassManip(TClass* ){
4735  }
4736 
4737 } // end of namespace ROOT
4738 
4739 namespace ROOT {
4740  static TClass *NTuplecLcLItemlEdoublegR_Dictionary();
4741  static void NTuplecLcLItemlEdoublegR_TClassManip(TClass*);
4742  static void *new_NTuplecLcLItemlEdoublegR(void *p = 0);
4743  static void *newArray_NTuplecLcLItemlEdoublegR(Long_t size, void *p);
4744  static void delete_NTuplecLcLItemlEdoublegR(void *p);
4745  static void deleteArray_NTuplecLcLItemlEdoublegR(void *p);
4746  static void destruct_NTuplecLcLItemlEdoublegR(void *p);
4747 
4748  // Function generating the singleton type initializer
4749  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<double>*)
4750  {
4751  ::NTuple::Item<double> *ptr = 0;
4752  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<double>));
4753  static ::ROOT::TGenericClassInfo
4754  instance("NTuple::Item<double>", "GaudiKernel/NTuple.h", 260,
4755  typeid(::NTuple::Item<double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4756  &NTuplecLcLItemlEdoublegR_Dictionary, isa_proxy, 4,
4757  sizeof(::NTuple::Item<double>) );
4758  instance.SetNew(&new_NTuplecLcLItemlEdoublegR);
4759  instance.SetNewArray(&newArray_NTuplecLcLItemlEdoublegR);
4760  instance.SetDelete(&delete_NTuplecLcLItemlEdoublegR);
4761  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEdoublegR);
4762  instance.SetDestructor(&destruct_NTuplecLcLItemlEdoublegR);
4763  return &instance;
4764  }
4765  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<double>*)
4766  {
4767  return GenerateInitInstanceLocal((::NTuple::Item<double>*)0);
4768  }
4769  // Static variable to force the class initialization
4770  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<double>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4771 
4772  // Dictionary for non-ClassDef classes
4773  static TClass *NTuplecLcLItemlEdoublegR_Dictionary() {
4774  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<double>*)0x0)->GetClass();
4775  NTuplecLcLItemlEdoublegR_TClassManip(theClass);
4776  return theClass;
4777  }
4778 
4779  static void NTuplecLcLItemlEdoublegR_TClassManip(TClass* ){
4780  }
4781 
4782 } // end of namespace ROOT
4783 
4784 namespace ROOT {
4785  static TClass *NTuplecLcLArraylEboolgR_Dictionary();
4786  static void NTuplecLcLArraylEboolgR_TClassManip(TClass*);
4787  static void *new_NTuplecLcLArraylEboolgR(void *p = 0);
4788  static void *newArray_NTuplecLcLArraylEboolgR(Long_t size, void *p);
4789  static void delete_NTuplecLcLArraylEboolgR(void *p);
4790  static void deleteArray_NTuplecLcLArraylEboolgR(void *p);
4791  static void destruct_NTuplecLcLArraylEboolgR(void *p);
4792 
4793  // Function generating the singleton type initializer
4794  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<bool>*)
4795  {
4796  ::NTuple::Array<bool> *ptr = 0;
4797  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<bool>));
4798  static ::ROOT::TGenericClassInfo
4799  instance("NTuple::Array<bool>", "GaudiKernel/NTuple.h", 343,
4800  typeid(::NTuple::Array<bool>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4801  &NTuplecLcLArraylEboolgR_Dictionary, isa_proxy, 4,
4802  sizeof(::NTuple::Array<bool>) );
4803  instance.SetNew(&new_NTuplecLcLArraylEboolgR);
4804  instance.SetNewArray(&newArray_NTuplecLcLArraylEboolgR);
4805  instance.SetDelete(&delete_NTuplecLcLArraylEboolgR);
4806  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEboolgR);
4807  instance.SetDestructor(&destruct_NTuplecLcLArraylEboolgR);
4808  return &instance;
4809  }
4810  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<bool>*)
4811  {
4812  return GenerateInitInstanceLocal((::NTuple::Array<bool>*)0);
4813  }
4814  // Static variable to force the class initialization
4815  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<bool>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4816 
4817  // Dictionary for non-ClassDef classes
4818  static TClass *NTuplecLcLArraylEboolgR_Dictionary() {
4819  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<bool>*)0x0)->GetClass();
4820  NTuplecLcLArraylEboolgR_TClassManip(theClass);
4821  return theClass;
4822  }
4823 
4824  static void NTuplecLcLArraylEboolgR_TClassManip(TClass* ){
4825  }
4826 
4827 } // end of namespace ROOT
4828 
4829 namespace ROOT {
4830  static TClass *NTuplecLcLArraylEchargR_Dictionary();
4831  static void NTuplecLcLArraylEchargR_TClassManip(TClass*);
4832  static void *new_NTuplecLcLArraylEchargR(void *p = 0);
4833  static void *newArray_NTuplecLcLArraylEchargR(Long_t size, void *p);
4834  static void delete_NTuplecLcLArraylEchargR(void *p);
4835  static void deleteArray_NTuplecLcLArraylEchargR(void *p);
4836  static void destruct_NTuplecLcLArraylEchargR(void *p);
4837 
4838  // Function generating the singleton type initializer
4839  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<char>*)
4840  {
4841  ::NTuple::Array<char> *ptr = 0;
4842  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<char>));
4843  static ::ROOT::TGenericClassInfo
4844  instance("NTuple::Array<char>", "GaudiKernel/NTuple.h", 343,
4845  typeid(::NTuple::Array<char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4846  &NTuplecLcLArraylEchargR_Dictionary, isa_proxy, 4,
4847  sizeof(::NTuple::Array<char>) );
4848  instance.SetNew(&new_NTuplecLcLArraylEchargR);
4849  instance.SetNewArray(&newArray_NTuplecLcLArraylEchargR);
4850  instance.SetDelete(&delete_NTuplecLcLArraylEchargR);
4851  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEchargR);
4852  instance.SetDestructor(&destruct_NTuplecLcLArraylEchargR);
4853  return &instance;
4854  }
4855  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<char>*)
4856  {
4857  return GenerateInitInstanceLocal((::NTuple::Array<char>*)0);
4858  }
4859  // Static variable to force the class initialization
4860  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4861 
4862  // Dictionary for non-ClassDef classes
4863  static TClass *NTuplecLcLArraylEchargR_Dictionary() {
4864  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<char>*)0x0)->GetClass();
4865  NTuplecLcLArraylEchargR_TClassManip(theClass);
4866  return theClass;
4867  }
4868 
4869  static void NTuplecLcLArraylEchargR_TClassManip(TClass* ){
4870  }
4871 
4872 } // end of namespace ROOT
4873 
4874 namespace ROOT {
4875  static TClass *NTuplecLcLArraylEunsignedsPchargR_Dictionary();
4876  static void NTuplecLcLArraylEunsignedsPchargR_TClassManip(TClass*);
4877  static void *new_NTuplecLcLArraylEunsignedsPchargR(void *p = 0);
4878  static void *newArray_NTuplecLcLArraylEunsignedsPchargR(Long_t size, void *p);
4879  static void delete_NTuplecLcLArraylEunsignedsPchargR(void *p);
4880  static void deleteArray_NTuplecLcLArraylEunsignedsPchargR(void *p);
4881  static void destruct_NTuplecLcLArraylEunsignedsPchargR(void *p);
4882 
4883  // Function generating the singleton type initializer
4884  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<unsigned char>*)
4885  {
4886  ::NTuple::Array<unsigned char> *ptr = 0;
4887  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<unsigned char>));
4888  static ::ROOT::TGenericClassInfo
4889  instance("NTuple::Array<unsigned char>", "GaudiKernel/NTuple.h", 343,
4890  typeid(::NTuple::Array<unsigned char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4891  &NTuplecLcLArraylEunsignedsPchargR_Dictionary, isa_proxy, 4,
4892  sizeof(::NTuple::Array<unsigned char>) );
4893  instance.SetNew(&new_NTuplecLcLArraylEunsignedsPchargR);
4894  instance.SetNewArray(&newArray_NTuplecLcLArraylEunsignedsPchargR);
4895  instance.SetDelete(&delete_NTuplecLcLArraylEunsignedsPchargR);
4896  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEunsignedsPchargR);
4897  instance.SetDestructor(&destruct_NTuplecLcLArraylEunsignedsPchargR);
4898  return &instance;
4899  }
4900  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<unsigned char>*)
4901  {
4902  return GenerateInitInstanceLocal((::NTuple::Array<unsigned char>*)0);
4903  }
4904  // Static variable to force the class initialization
4905  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<unsigned char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4906 
4907  // Dictionary for non-ClassDef classes
4908  static TClass *NTuplecLcLArraylEunsignedsPchargR_Dictionary() {
4909  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<unsigned char>*)0x0)->GetClass();
4910  NTuplecLcLArraylEunsignedsPchargR_TClassManip(theClass);
4911  return theClass;
4912  }
4913 
4914  static void NTuplecLcLArraylEunsignedsPchargR_TClassManip(TClass* ){
4915  }
4916 
4917 } // end of namespace ROOT
4918 
4919 namespace ROOT {
4920  static TClass *NTuplecLcLArraylEshortgR_Dictionary();
4921  static void NTuplecLcLArraylEshortgR_TClassManip(TClass*);
4922  static void *new_NTuplecLcLArraylEshortgR(void *p = 0);
4923  static void *newArray_NTuplecLcLArraylEshortgR(Long_t size, void *p);
4924  static void delete_NTuplecLcLArraylEshortgR(void *p);
4925  static void deleteArray_NTuplecLcLArraylEshortgR(void *p);
4926  static void destruct_NTuplecLcLArraylEshortgR(void *p);
4927 
4928  // Function generating the singleton type initializer
4929  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<short>*)
4930  {
4931  ::NTuple::Array<short> *ptr = 0;
4932  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<short>));
4933  static ::ROOT::TGenericClassInfo
4934  instance("NTuple::Array<short>", "GaudiKernel/NTuple.h", 343,
4935  typeid(::NTuple::Array<short>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4936  &NTuplecLcLArraylEshortgR_Dictionary, isa_proxy, 4,
4937  sizeof(::NTuple::Array<short>) );
4938  instance.SetNew(&new_NTuplecLcLArraylEshortgR);
4939  instance.SetNewArray(&newArray_NTuplecLcLArraylEshortgR);
4940  instance.SetDelete(&delete_NTuplecLcLArraylEshortgR);
4941  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEshortgR);
4942  instance.SetDestructor(&destruct_NTuplecLcLArraylEshortgR);
4943  return &instance;
4944  }
4945  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<short>*)
4946  {
4947  return GenerateInitInstanceLocal((::NTuple::Array<short>*)0);
4948  }
4949  // Static variable to force the class initialization
4950  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<short>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4951 
4952  // Dictionary for non-ClassDef classes
4953  static TClass *NTuplecLcLArraylEshortgR_Dictionary() {
4954  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<short>*)0x0)->GetClass();
4955  NTuplecLcLArraylEshortgR_TClassManip(theClass);
4956  return theClass;
4957  }
4958 
4959  static void NTuplecLcLArraylEshortgR_TClassManip(TClass* ){
4960  }
4961 
4962 } // end of namespace ROOT
4963 
4964 namespace ROOT {
4965  static TClass *NTuplecLcLArraylEunsignedsPshortgR_Dictionary();
4966  static void NTuplecLcLArraylEunsignedsPshortgR_TClassManip(TClass*);
4967  static void *new_NTuplecLcLArraylEunsignedsPshortgR(void *p = 0);
4968  static void *newArray_NTuplecLcLArraylEunsignedsPshortgR(Long_t size, void *p);
4969  static void delete_NTuplecLcLArraylEunsignedsPshortgR(void *p);
4970  static void deleteArray_NTuplecLcLArraylEunsignedsPshortgR(void *p);
4971  static void destruct_NTuplecLcLArraylEunsignedsPshortgR(void *p);
4972 
4973  // Function generating the singleton type initializer
4974  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<unsigned short>*)
4975  {
4976  ::NTuple::Array<unsigned short> *ptr = 0;
4977  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<unsigned short>));
4978  static ::ROOT::TGenericClassInfo
4979  instance("NTuple::Array<unsigned short>", "GaudiKernel/NTuple.h", 343,
4980  typeid(::NTuple::Array<unsigned short>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4981  &NTuplecLcLArraylEunsignedsPshortgR_Dictionary, isa_proxy, 4,
4982  sizeof(::NTuple::Array<unsigned short>) );
4983  instance.SetNew(&new_NTuplecLcLArraylEunsignedsPshortgR);
4984  instance.SetNewArray(&newArray_NTuplecLcLArraylEunsignedsPshortgR);
4985  instance.SetDelete(&delete_NTuplecLcLArraylEunsignedsPshortgR);
4986  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEunsignedsPshortgR);
4987  instance.SetDestructor(&destruct_NTuplecLcLArraylEunsignedsPshortgR);
4988  return &instance;
4989  }
4990  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<unsigned short>*)
4991  {
4992  return GenerateInitInstanceLocal((::NTuple::Array<unsigned short>*)0);
4993  }
4994  // Static variable to force the class initialization
4995  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<unsigned short>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4996 
4997  // Dictionary for non-ClassDef classes
4998  static TClass *NTuplecLcLArraylEunsignedsPshortgR_Dictionary() {
4999  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<unsigned short>*)0x0)->GetClass();
5000  NTuplecLcLArraylEunsignedsPshortgR_TClassManip(theClass);
5001  return theClass;
5002  }
5003 
5004  static void NTuplecLcLArraylEunsignedsPshortgR_TClassManip(TClass* ){
5005  }
5006 
5007 } // end of namespace ROOT
5008 
5009 namespace ROOT {
5010  static TClass *NTuplecLcLArraylElonggR_Dictionary();
5011  static void NTuplecLcLArraylElonggR_TClassManip(TClass*);
5012  static void *new_NTuplecLcLArraylElonggR(void *p = 0);
5013  static void *newArray_NTuplecLcLArraylElonggR(Long_t size, void *p);
5014  static void delete_NTuplecLcLArraylElonggR(void *p);
5015  static void deleteArray_NTuplecLcLArraylElonggR(void *p);
5016  static void destruct_NTuplecLcLArraylElonggR(void *p);
5017 
5018  // Function generating the singleton type initializer
5019  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<long>*)
5020  {
5021  ::NTuple::Array<long> *ptr = 0;
5022  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<long>));
5023  static ::ROOT::TGenericClassInfo
5024  instance("NTuple::Array<long>", "GaudiKernel/NTuple.h", 343,
5025  typeid(::NTuple::Array<long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5026  &NTuplecLcLArraylElonggR_Dictionary, isa_proxy, 4,
5027  sizeof(::NTuple::Array<long>) );
5028  instance.SetNew(&new_NTuplecLcLArraylElonggR);
5029  instance.SetNewArray(&newArray_NTuplecLcLArraylElonggR);
5030  instance.SetDelete(&delete_NTuplecLcLArraylElonggR);
5031  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylElonggR);
5032  instance.SetDestructor(&destruct_NTuplecLcLArraylElonggR);
5033  return &instance;
5034  }
5035  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<long>*)
5036  {
5037  return GenerateInitInstanceLocal((::NTuple::Array<long>*)0);
5038  }
5039  // Static variable to force the class initialization
5040  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5041 
5042  // Dictionary for non-ClassDef classes
5043  static TClass *NTuplecLcLArraylElonggR_Dictionary() {
5044  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<long>*)0x0)->GetClass();
5045  NTuplecLcLArraylElonggR_TClassManip(theClass);
5046  return theClass;
5047  }
5048 
5049  static void NTuplecLcLArraylElonggR_TClassManip(TClass* ){
5050  }
5051 
5052 } // end of namespace ROOT
5053 
5054 namespace ROOT {
5055  static TClass *NTuplecLcLArraylEunsignedsPlonggR_Dictionary();
5056  static void NTuplecLcLArraylEunsignedsPlonggR_TClassManip(TClass*);
5057  static void *new_NTuplecLcLArraylEunsignedsPlonggR(void *p = 0);
5058  static void *newArray_NTuplecLcLArraylEunsignedsPlonggR(Long_t size, void *p);
5059  static void delete_NTuplecLcLArraylEunsignedsPlonggR(void *p);
5060  static void deleteArray_NTuplecLcLArraylEunsignedsPlonggR(void *p);
5061  static void destruct_NTuplecLcLArraylEunsignedsPlonggR(void *p);
5062 
5063  // Function generating the singleton type initializer
5064  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<unsigned long>*)
5065  {
5066  ::NTuple::Array<unsigned long> *ptr = 0;
5067  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<unsigned long>));
5068  static ::ROOT::TGenericClassInfo
5069  instance("NTuple::Array<unsigned long>", "GaudiKernel/NTuple.h", 343,
5070  typeid(::NTuple::Array<unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5071  &NTuplecLcLArraylEunsignedsPlonggR_Dictionary, isa_proxy, 4,
5072  sizeof(::NTuple::Array<unsigned long>) );
5073  instance.SetNew(&new_NTuplecLcLArraylEunsignedsPlonggR);
5074  instance.SetNewArray(&newArray_NTuplecLcLArraylEunsignedsPlonggR);
5075  instance.SetDelete(&delete_NTuplecLcLArraylEunsignedsPlonggR);
5076  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEunsignedsPlonggR);
5077  instance.SetDestructor(&destruct_NTuplecLcLArraylEunsignedsPlonggR);
5078  return &instance;
5079  }
5080  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<unsigned long>*)
5081  {
5082  return GenerateInitInstanceLocal((::NTuple::Array<unsigned long>*)0);
5083  }
5084  // Static variable to force the class initialization
5085  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5086 
5087  // Dictionary for non-ClassDef classes
5088  static TClass *NTuplecLcLArraylEunsignedsPlonggR_Dictionary() {
5089  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<unsigned long>*)0x0)->GetClass();
5090  NTuplecLcLArraylEunsignedsPlonggR_TClassManip(theClass);
5091  return theClass;
5092  }
5093 
5094  static void NTuplecLcLArraylEunsignedsPlonggR_TClassManip(TClass* ){
5095  }
5096 
5097 } // end of namespace ROOT
5098 
5099 namespace ROOT {
5100  static TClass *NTuplecLcLArraylEintgR_Dictionary();
5101  static void NTuplecLcLArraylEintgR_TClassManip(TClass*);
5102  static void *new_NTuplecLcLArraylEintgR(void *p = 0);
5103  static void *newArray_NTuplecLcLArraylEintgR(Long_t size, void *p);
5104  static void delete_NTuplecLcLArraylEintgR(void *p);
5105  static void deleteArray_NTuplecLcLArraylEintgR(void *p);
5106  static void destruct_NTuplecLcLArraylEintgR(void *p);
5107 
5108  // Function generating the singleton type initializer
5109  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<int>*)
5110  {
5111  ::NTuple::Array<int> *ptr = 0;
5112  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<int>));
5113  static ::ROOT::TGenericClassInfo
5114  instance("NTuple::Array<int>", "GaudiKernel/NTuple.h", 343,
5115  typeid(::NTuple::Array<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5116  &NTuplecLcLArraylEintgR_Dictionary, isa_proxy, 4,
5117  sizeof(::NTuple::Array<int>) );
5118  instance.SetNew(&new_NTuplecLcLArraylEintgR);
5119  instance.SetNewArray(&newArray_NTuplecLcLArraylEintgR);
5120  instance.SetDelete(&delete_NTuplecLcLArraylEintgR);
5121  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEintgR);
5122  instance.SetDestructor(&destruct_NTuplecLcLArraylEintgR);
5123  return &instance;
5124  }
5125  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<int>*)
5126  {
5127  return GenerateInitInstanceLocal((::NTuple::Array<int>*)0);
5128  }
5129  // Static variable to force the class initialization
5130  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5131 
5132  // Dictionary for non-ClassDef classes
5133  static TClass *NTuplecLcLArraylEintgR_Dictionary() {
5134  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<int>*)0x0)->GetClass();
5135  NTuplecLcLArraylEintgR_TClassManip(theClass);
5136  return theClass;
5137  }
5138 
5139  static void NTuplecLcLArraylEintgR_TClassManip(TClass* ){
5140  }
5141 
5142 } // end of namespace ROOT
5143 
5144 namespace ROOT {
5145  static TClass *NTuplecLcLArraylEunsignedsPintgR_Dictionary();
5146  static void NTuplecLcLArraylEunsignedsPintgR_TClassManip(TClass*);
5147  static void *new_NTuplecLcLArraylEunsignedsPintgR(void *p = 0);
5148  static void *newArray_NTuplecLcLArraylEunsignedsPintgR(Long_t size, void *p);
5149  static void delete_NTuplecLcLArraylEunsignedsPintgR(void *p);
5150  static void deleteArray_NTuplecLcLArraylEunsignedsPintgR(void *p);
5151  static void destruct_NTuplecLcLArraylEunsignedsPintgR(void *p);
5152 
5153  // Function generating the singleton type initializer
5154  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<unsigned int>*)
5155  {
5156  ::NTuple::Array<unsigned int> *ptr = 0;
5157  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<unsigned int>));
5158  static ::ROOT::TGenericClassInfo
5159  instance("NTuple::Array<unsigned int>", "GaudiKernel/NTuple.h", 343,
5160  typeid(::NTuple::Array<unsigned int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5161  &NTuplecLcLArraylEunsignedsPintgR_Dictionary, isa_proxy, 4,
5162  sizeof(::NTuple::Array<unsigned int>) );
5163  instance.SetNew(&new_NTuplecLcLArraylEunsignedsPintgR);
5164  instance.SetNewArray(&newArray_NTuplecLcLArraylEunsignedsPintgR);
5165  instance.SetDelete(&delete_NTuplecLcLArraylEunsignedsPintgR);
5166  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEunsignedsPintgR);
5167  instance.SetDestructor(&destruct_NTuplecLcLArraylEunsignedsPintgR);
5168  return &instance;
5169  }
5170  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<unsigned int>*)
5171  {
5172  return GenerateInitInstanceLocal((::NTuple::Array<unsigned int>*)0);
5173  }
5174  // Static variable to force the class initialization
5175  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5176 
5177  // Dictionary for non-ClassDef classes
5178  static TClass *NTuplecLcLArraylEunsignedsPintgR_Dictionary() {
5179  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<unsigned int>*)0x0)->GetClass();
5180  NTuplecLcLArraylEunsignedsPintgR_TClassManip(theClass);
5181  return theClass;
5182  }
5183 
5184  static void NTuplecLcLArraylEunsignedsPintgR_TClassManip(TClass* ){
5185  }
5186 
5187 } // end of namespace ROOT
5188 
5189 namespace ROOT {
5190  static TClass *NTuplecLcLArraylEfloatgR_Dictionary();
5191  static void NTuplecLcLArraylEfloatgR_TClassManip(TClass*);
5192  static void *new_NTuplecLcLArraylEfloatgR(void *p = 0);
5193  static void *newArray_NTuplecLcLArraylEfloatgR(Long_t size, void *p);
5194  static void delete_NTuplecLcLArraylEfloatgR(void *p);
5195  static void deleteArray_NTuplecLcLArraylEfloatgR(void *p);
5196  static void destruct_NTuplecLcLArraylEfloatgR(void *p);
5197 
5198  // Function generating the singleton type initializer
5199  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<float>*)
5200  {
5201  ::NTuple::Array<float> *ptr = 0;
5202  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<float>));
5203  static ::ROOT::TGenericClassInfo
5204  instance("NTuple::Array<float>", "GaudiKernel/NTuple.h", 343,
5205  typeid(::NTuple::Array<float>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5206  &NTuplecLcLArraylEfloatgR_Dictionary, isa_proxy, 4,
5207  sizeof(::NTuple::Array<float>) );
5208  instance.SetNew(&new_NTuplecLcLArraylEfloatgR);
5209  instance.SetNewArray(&newArray_NTuplecLcLArraylEfloatgR);
5210  instance.SetDelete(&delete_NTuplecLcLArraylEfloatgR);
5211  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEfloatgR);
5212  instance.SetDestructor(&destruct_NTuplecLcLArraylEfloatgR);
5213  return &instance;
5214  }
5215  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<float>*)
5216  {
5217  return GenerateInitInstanceLocal((::NTuple::Array<float>*)0);
5218  }
5219  // Static variable to force the class initialization
5220  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<float>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5221 
5222  // Dictionary for non-ClassDef classes
5223  static TClass *NTuplecLcLArraylEfloatgR_Dictionary() {
5224  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<float>*)0x0)->GetClass();
5225  NTuplecLcLArraylEfloatgR_TClassManip(theClass);
5226  return theClass;
5227  }
5228 
5229  static void NTuplecLcLArraylEfloatgR_TClassManip(TClass* ){
5230  }
5231 
5232 } // end of namespace ROOT
5233 
5234 namespace ROOT {
5235  static TClass *NTuplecLcLArraylEdoublegR_Dictionary();
5236  static void NTuplecLcLArraylEdoublegR_TClassManip(TClass*);
5237  static void *new_NTuplecLcLArraylEdoublegR(void *p = 0);
5238  static void *newArray_NTuplecLcLArraylEdoublegR(Long_t size, void *p);
5239  static void delete_NTuplecLcLArraylEdoublegR(void *p);
5240  static void deleteArray_NTuplecLcLArraylEdoublegR(void *p);
5241  static void destruct_NTuplecLcLArraylEdoublegR(void *p);
5242 
5243  // Function generating the singleton type initializer
5244  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<double>*)
5245  {
5246  ::NTuple::Array<double> *ptr = 0;
5247  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<double>));
5248  static ::ROOT::TGenericClassInfo
5249  instance("NTuple::Array<double>", "GaudiKernel/NTuple.h", 343,
5250  typeid(::NTuple::Array<double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5251  &NTuplecLcLArraylEdoublegR_Dictionary, isa_proxy, 4,
5252  sizeof(::NTuple::Array<double>) );
5253  instance.SetNew(&new_NTuplecLcLArraylEdoublegR);
5254  instance.SetNewArray(&newArray_NTuplecLcLArraylEdoublegR);
5255  instance.SetDelete(&delete_NTuplecLcLArraylEdoublegR);
5256  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEdoublegR);
5257  instance.SetDestructor(&destruct_NTuplecLcLArraylEdoublegR);
5258  return &instance;
5259  }
5260  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<double>*)
5261  {
5262  return GenerateInitInstanceLocal((::NTuple::Array<double>*)0);
5263  }
5264  // Static variable to force the class initialization
5265  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<double>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5266 
5267  // Dictionary for non-ClassDef classes
5268  static TClass *NTuplecLcLArraylEdoublegR_Dictionary() {
5269  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<double>*)0x0)->GetClass();
5270  NTuplecLcLArraylEdoublegR_TClassManip(theClass);
5271  return theClass;
5272  }
5273 
5274  static void NTuplecLcLArraylEdoublegR_TClassManip(TClass* ){
5275  }
5276 
5277 } // end of namespace ROOT
5278 
5279 namespace ROOT {
5280  static TClass *NTuplecLcLMatrixlEboolgR_Dictionary();
5281  static void NTuplecLcLMatrixlEboolgR_TClassManip(TClass*);
5282  static void *new_NTuplecLcLMatrixlEboolgR(void *p = 0);
5283  static void *newArray_NTuplecLcLMatrixlEboolgR(Long_t size, void *p);
5284  static void delete_NTuplecLcLMatrixlEboolgR(void *p);
5285  static void deleteArray_NTuplecLcLMatrixlEboolgR(void *p);
5286  static void destruct_NTuplecLcLMatrixlEboolgR(void *p);
5287 
5288  // Function generating the singleton type initializer
5289  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<bool>*)
5290  {
5291  ::NTuple::Matrix<bool> *ptr = 0;
5292  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<bool>));
5293  static ::ROOT::TGenericClassInfo
5294  instance("NTuple::Matrix<bool>", "GaudiKernel/NTuple.h", 375,
5295  typeid(::NTuple::Matrix<bool>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5296  &NTuplecLcLMatrixlEboolgR_Dictionary, isa_proxy, 4,
5297  sizeof(::NTuple::Matrix<bool>) );
5298  instance.SetNew(&new_NTuplecLcLMatrixlEboolgR);
5299  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEboolgR);
5300  instance.SetDelete(&delete_NTuplecLcLMatrixlEboolgR);
5301  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEboolgR);
5302  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEboolgR);
5303  return &instance;
5304  }
5305  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<bool>*)
5306  {
5307  return GenerateInitInstanceLocal((::NTuple::Matrix<bool>*)0);
5308  }
5309  // Static variable to force the class initialization
5310  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<bool>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5311 
5312  // Dictionary for non-ClassDef classes
5313  static TClass *NTuplecLcLMatrixlEboolgR_Dictionary() {
5314  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<bool>*)0x0)->GetClass();
5315  NTuplecLcLMatrixlEboolgR_TClassManip(theClass);
5316  return theClass;
5317  }
5318 
5319  static void NTuplecLcLMatrixlEboolgR_TClassManip(TClass* ){
5320  }
5321 
5322 } // end of namespace ROOT
5323 
5324 namespace ROOT {
5325  static TClass *NTuplecLcLMatrixlEchargR_Dictionary();
5326  static void NTuplecLcLMatrixlEchargR_TClassManip(TClass*);
5327  static void *new_NTuplecLcLMatrixlEchargR(void *p = 0);
5328  static void *newArray_NTuplecLcLMatrixlEchargR(Long_t size, void *p);
5329  static void delete_NTuplecLcLMatrixlEchargR(void *p);
5330  static void deleteArray_NTuplecLcLMatrixlEchargR(void *p);
5331  static void destruct_NTuplecLcLMatrixlEchargR(void *p);
5332 
5333  // Function generating the singleton type initializer
5334  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<char>*)
5335  {
5336  ::NTuple::Matrix<char> *ptr = 0;
5337  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<char>));
5338  static ::ROOT::TGenericClassInfo
5339  instance("NTuple::Matrix<char>", "GaudiKernel/NTuple.h", 375,
5340  typeid(::NTuple::Matrix<char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5341  &NTuplecLcLMatrixlEchargR_Dictionary, isa_proxy, 4,
5342  sizeof(::NTuple::Matrix<char>) );
5343  instance.SetNew(&new_NTuplecLcLMatrixlEchargR);
5344  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEchargR);
5345  instance.SetDelete(&delete_NTuplecLcLMatrixlEchargR);
5346  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEchargR);
5347  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEchargR);
5348  return &instance;
5349  }
5350  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<char>*)
5351  {
5352  return GenerateInitInstanceLocal((::NTuple::Matrix<char>*)0);
5353  }
5354  // Static variable to force the class initialization
5355  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5356 
5357  // Dictionary for non-ClassDef classes
5358  static TClass *NTuplecLcLMatrixlEchargR_Dictionary() {
5359  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<char>*)0x0)->GetClass();
5360  NTuplecLcLMatrixlEchargR_TClassManip(theClass);
5361  return theClass;
5362  }
5363 
5364  static void NTuplecLcLMatrixlEchargR_TClassManip(TClass* ){
5365  }
5366 
5367 } // end of namespace ROOT
5368 
5369 namespace ROOT {
5370  static TClass *NTuplecLcLMatrixlEunsignedsPchargR_Dictionary();
5371  static void NTuplecLcLMatrixlEunsignedsPchargR_TClassManip(TClass*);
5372  static void *new_NTuplecLcLMatrixlEunsignedsPchargR(void *p = 0);
5373  static void *newArray_NTuplecLcLMatrixlEunsignedsPchargR(Long_t size, void *p);
5374  static void delete_NTuplecLcLMatrixlEunsignedsPchargR(void *p);
5375  static void deleteArray_NTuplecLcLMatrixlEunsignedsPchargR(void *p);
5376  static void destruct_NTuplecLcLMatrixlEunsignedsPchargR(void *p);
5377 
5378  // Function generating the singleton type initializer
5379  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<unsigned char>*)
5380  {
5381  ::NTuple::Matrix<unsigned char> *ptr = 0;
5382  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<unsigned char>));
5383  static ::ROOT::TGenericClassInfo
5384  instance("NTuple::Matrix<unsigned char>", "GaudiKernel/NTuple.h", 375,
5385  typeid(::NTuple::Matrix<unsigned char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5386  &NTuplecLcLMatrixlEunsignedsPchargR_Dictionary, isa_proxy, 4,
5387  sizeof(::NTuple::Matrix<unsigned char>) );
5388  instance.SetNew(&new_NTuplecLcLMatrixlEunsignedsPchargR);
5389  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEunsignedsPchargR);
5390  instance.SetDelete(&delete_NTuplecLcLMatrixlEunsignedsPchargR);
5391  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEunsignedsPchargR);
5392  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEunsignedsPchargR);
5393  return &instance;
5394  }
5395  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<unsigned char>*)
5396  {
5397  return GenerateInitInstanceLocal((::NTuple::Matrix<unsigned char>*)0);
5398  }
5399  // Static variable to force the class initialization
5400  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5401 
5402  // Dictionary for non-ClassDef classes
5403  static TClass *NTuplecLcLMatrixlEunsignedsPchargR_Dictionary() {
5404  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned char>*)0x0)->GetClass();
5405  NTuplecLcLMatrixlEunsignedsPchargR_TClassManip(theClass);
5406  return theClass;
5407  }
5408 
5409  static void NTuplecLcLMatrixlEunsignedsPchargR_TClassManip(TClass* ){
5410  }
5411 
5412 } // end of namespace ROOT
5413 
5414 namespace ROOT {
5415  static TClass *NTuplecLcLMatrixlEshortgR_Dictionary();
5416  static void NTuplecLcLMatrixlEshortgR_TClassManip(TClass*);
5417  static void *new_NTuplecLcLMatrixlEshortgR(void *p = 0);
5418  static void *newArray_NTuplecLcLMatrixlEshortgR(Long_t size, void *p);
5419  static void delete_NTuplecLcLMatrixlEshortgR(void *p);
5420  static void deleteArray_NTuplecLcLMatrixlEshortgR(void *p);
5421  static void destruct_NTuplecLcLMatrixlEshortgR(void *p);
5422 
5423  // Function generating the singleton type initializer
5424  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<short>*)
5425  {
5426  ::NTuple::Matrix<short> *ptr = 0;
5427  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<short>));
5428  static ::ROOT::TGenericClassInfo
5429  instance("NTuple::Matrix<short>", "GaudiKernel/NTuple.h", 375,
5430  typeid(::NTuple::Matrix<short>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5431  &NTuplecLcLMatrixlEshortgR_Dictionary, isa_proxy, 4,
5432  sizeof(::NTuple::Matrix<short>) );
5433  instance.SetNew(&new_NTuplecLcLMatrixlEshortgR);
5434  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEshortgR);
5435  instance.SetDelete(&delete_NTuplecLcLMatrixlEshortgR);
5436  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEshortgR);
5437  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEshortgR);
5438  return &instance;
5439  }
5440  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<short>*)
5441  {
5442  return GenerateInitInstanceLocal((::NTuple::Matrix<short>*)0);
5443  }
5444  // Static variable to force the class initialization
5445  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<short>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5446 
5447  // Dictionary for non-ClassDef classes
5448  static TClass *NTuplecLcLMatrixlEshortgR_Dictionary() {
5449  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<short>*)0x0)->GetClass();
5450  NTuplecLcLMatrixlEshortgR_TClassManip(theClass);
5451  return theClass;
5452  }
5453 
5454  static void NTuplecLcLMatrixlEshortgR_TClassManip(TClass* ){
5455  }
5456 
5457 } // end of namespace ROOT
5458 
5459 namespace ROOT {
5460  static TClass *NTuplecLcLMatrixlEunsignedsPshortgR_Dictionary();
5461  static void NTuplecLcLMatrixlEunsignedsPshortgR_TClassManip(TClass*);
5462  static void *new_NTuplecLcLMatrixlEunsignedsPshortgR(void *p = 0);
5463  static void *newArray_NTuplecLcLMatrixlEunsignedsPshortgR(Long_t size, void *p);
5464  static void delete_NTuplecLcLMatrixlEunsignedsPshortgR(void *p);
5465  static void deleteArray_NTuplecLcLMatrixlEunsignedsPshortgR(void *p);
5466  static void destruct_NTuplecLcLMatrixlEunsignedsPshortgR(void *p);
5467 
5468  // Function generating the singleton type initializer
5469  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<unsigned short>*)
5470  {
5471  ::NTuple::Matrix<unsigned short> *ptr = 0;
5472  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<unsigned short>));
5473  static ::ROOT::TGenericClassInfo
5474  instance("NTuple::Matrix<unsigned short>", "GaudiKernel/NTuple.h", 375,
5475  typeid(::NTuple::Matrix<unsigned short>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5476  &NTuplecLcLMatrixlEunsignedsPshortgR_Dictionary, isa_proxy, 4,
5477  sizeof(::NTuple::Matrix<unsigned short>) );
5478  instance.SetNew(&new_NTuplecLcLMatrixlEunsignedsPshortgR);
5479  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEunsignedsPshortgR);
5480  instance.SetDelete(&delete_NTuplecLcLMatrixlEunsignedsPshortgR);
5481  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEunsignedsPshortgR);
5482  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEunsignedsPshortgR);
5483  return &instance;
5484  }
5485  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<unsigned short>*)
5486  {
5487  return GenerateInitInstanceLocal((::NTuple::Matrix<unsigned short>*)0);
5488  }
5489  // Static variable to force the class initialization
5490  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned short>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5491 
5492  // Dictionary for non-ClassDef classes
5493  static TClass *NTuplecLcLMatrixlEunsignedsPshortgR_Dictionary() {
5494  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned short>*)0x0)->GetClass();
5495  NTuplecLcLMatrixlEunsignedsPshortgR_TClassManip(theClass);
5496  return theClass;
5497  }
5498 
5499  static void NTuplecLcLMatrixlEunsignedsPshortgR_TClassManip(TClass* ){
5500  }
5501 
5502 } // end of namespace ROOT
5503 
5504 namespace ROOT {
5505  static TClass *NTuplecLcLMatrixlElonggR_Dictionary();
5506  static void NTuplecLcLMatrixlElonggR_TClassManip(TClass*);
5507  static void *new_NTuplecLcLMatrixlElonggR(void *p = 0);
5508  static void *newArray_NTuplecLcLMatrixlElonggR(Long_t size, void *p);
5509  static void delete_NTuplecLcLMatrixlElonggR(void *p);
5510  static void deleteArray_NTuplecLcLMatrixlElonggR(void *p);
5511  static void destruct_NTuplecLcLMatrixlElonggR(void *p);
5512 
5513  // Function generating the singleton type initializer
5514  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<long>*)
5515  {
5516  ::NTuple::Matrix<long> *ptr = 0;
5517  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<long>));
5518  static ::ROOT::TGenericClassInfo
5519  instance("NTuple::Matrix<long>", "GaudiKernel/NTuple.h", 375,
5520  typeid(::NTuple::Matrix<long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5521  &NTuplecLcLMatrixlElonggR_Dictionary, isa_proxy, 4,
5522  sizeof(::NTuple::Matrix<long>) );
5523  instance.SetNew(&new_NTuplecLcLMatrixlElonggR);
5524  instance.SetNewArray(&newArray_NTuplecLcLMatrixlElonggR);
5525  instance.SetDelete(&delete_NTuplecLcLMatrixlElonggR);
5526  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlElonggR);
5527  instance.SetDestructor(&destruct_NTuplecLcLMatrixlElonggR);
5528  return &instance;
5529  }
5530  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<long>*)
5531  {
5532  return GenerateInitInstanceLocal((::NTuple::Matrix<long>*)0);
5533  }
5534  // Static variable to force the class initialization
5535  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5536 
5537  // Dictionary for non-ClassDef classes
5538  static TClass *NTuplecLcLMatrixlElonggR_Dictionary() {
5539  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<long>*)0x0)->GetClass();
5540  NTuplecLcLMatrixlElonggR_TClassManip(theClass);
5541  return theClass;
5542  }
5543 
5544  static void NTuplecLcLMatrixlElonggR_TClassManip(TClass* ){
5545  }
5546 
5547 } // end of namespace ROOT
5548 
5549 namespace ROOT {
5550  static TClass *NTuplecLcLMatrixlEunsignedsPlonggR_Dictionary();
5551  static void NTuplecLcLMatrixlEunsignedsPlonggR_TClassManip(TClass*);
5552  static void *new_NTuplecLcLMatrixlEunsignedsPlonggR(void *p = 0);
5553  static void *newArray_NTuplecLcLMatrixlEunsignedsPlonggR(Long_t size, void *p);
5554  static void delete_NTuplecLcLMatrixlEunsignedsPlonggR(void *p);
5555  static void deleteArray_NTuplecLcLMatrixlEunsignedsPlonggR(void *p);
5556  static void destruct_NTuplecLcLMatrixlEunsignedsPlonggR(void *p);
5557 
5558  // Function generating the singleton type initializer
5559  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<unsigned long>*)
5560  {
5561  ::NTuple::Matrix<unsigned long> *ptr = 0;
5562  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<unsigned long>));
5563  static ::ROOT::TGenericClassInfo
5564  instance("NTuple::Matrix<unsigned long>", "GaudiKernel/NTuple.h", 375,
5565  typeid(::NTuple::Matrix<unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5566  &NTuplecLcLMatrixlEunsignedsPlonggR_Dictionary, isa_proxy, 4,
5567  sizeof(::NTuple::Matrix<unsigned long>) );
5568  instance.SetNew(&new_NTuplecLcLMatrixlEunsignedsPlonggR);
5569  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEunsignedsPlonggR);
5570  instance.SetDelete(&delete_NTuplecLcLMatrixlEunsignedsPlonggR);
5571  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEunsignedsPlonggR);
5572  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEunsignedsPlonggR);
5573  return &instance;
5574  }
5575  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<unsigned long>*)
5576  {
5577  return GenerateInitInstanceLocal((::NTuple::Matrix<unsigned long>*)0);
5578  }
5579  // Static variable to force the class initialization
5580  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5581 
5582  // Dictionary for non-ClassDef classes
5583  static TClass *NTuplecLcLMatrixlEunsignedsPlonggR_Dictionary() {
5584  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned long>*)0x0)->GetClass();
5585  NTuplecLcLMatrixlEunsignedsPlonggR_TClassManip(theClass);
5586  return theClass;
5587  }
5588 
5589  static void NTuplecLcLMatrixlEunsignedsPlonggR_TClassManip(TClass* ){
5590  }
5591 
5592 } // end of namespace ROOT
5593 
5594 namespace ROOT {
5595  static TClass *NTuplecLcLMatrixlEintgR_Dictionary();
5596  static void NTuplecLcLMatrixlEintgR_TClassManip(TClass*);
5597  static void *new_NTuplecLcLMatrixlEintgR(void *p = 0);
5598  static void *newArray_NTuplecLcLMatrixlEintgR(Long_t size, void *p);
5599  static void delete_NTuplecLcLMatrixlEintgR(void *p);
5600  static void deleteArray_NTuplecLcLMatrixlEintgR(void *p);
5601  static void destruct_NTuplecLcLMatrixlEintgR(void *p);
5602 
5603  // Function generating the singleton type initializer
5604  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<int>*)
5605  {
5606  ::NTuple::Matrix<int> *ptr = 0;
5607  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<int>));
5608  static ::ROOT::TGenericClassInfo
5609  instance("NTuple::Matrix<int>", "GaudiKernel/NTuple.h", 375,
5610  typeid(::NTuple::Matrix<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5611  &NTuplecLcLMatrixlEintgR_Dictionary, isa_proxy, 4,
5612  sizeof(::NTuple::Matrix<int>) );
5613  instance.SetNew(&new_NTuplecLcLMatrixlEintgR);
5614  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEintgR);
5615  instance.SetDelete(&delete_NTuplecLcLMatrixlEintgR);
5616  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEintgR);
5617  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEintgR);
5618  return &instance;
5619  }
5620  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<int>*)
5621  {
5622  return GenerateInitInstanceLocal((::NTuple::Matrix<int>*)0);
5623  }
5624  // Static variable to force the class initialization
5625  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5626 
5627  // Dictionary for non-ClassDef classes
5628  static TClass *NTuplecLcLMatrixlEintgR_Dictionary() {
5629  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<int>*)0x0)->GetClass();
5630  NTuplecLcLMatrixlEintgR_TClassManip(theClass);
5631  return theClass;
5632  }
5633 
5634  static void NTuplecLcLMatrixlEintgR_TClassManip(TClass* ){
5635  }
5636 
5637 } // end of namespace ROOT
5638 
5639 namespace ROOT {
5640  static TClass *NTuplecLcLMatrixlEunsignedsPintgR_Dictionary();
5641  static void NTuplecLcLMatrixlEunsignedsPintgR_TClassManip(TClass*);
5642  static void *new_NTuplecLcLMatrixlEunsignedsPintgR(void *p = 0);
5643  static void *newArray_NTuplecLcLMatrixlEunsignedsPintgR(Long_t size, void *p);
5644  static void delete_NTuplecLcLMatrixlEunsignedsPintgR(void *p);
5645  static void deleteArray_NTuplecLcLMatrixlEunsignedsPintgR(void *p);
5646  static void destruct_NTuplecLcLMatrixlEunsignedsPintgR(void *p);
5647 
5648  // Function generating the singleton type initializer
5649  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<unsigned int>*)
5650  {
5651  ::NTuple::Matrix<unsigned int> *ptr = 0;
5652  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<unsigned int>));
5653  static ::ROOT::TGenericClassInfo
5654  instance("NTuple::Matrix<unsigned int>", "GaudiKernel/NTuple.h", 375,
5655  typeid(::NTuple::Matrix<unsigned int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5656  &NTuplecLcLMatrixlEunsignedsPintgR_Dictionary, isa_proxy, 4,
5657  sizeof(::NTuple::Matrix<unsigned int>) );
5658  instance.SetNew(&new_NTuplecLcLMatrixlEunsignedsPintgR);
5659  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEunsignedsPintgR);
5660  instance.SetDelete(&delete_NTuplecLcLMatrixlEunsignedsPintgR);
5661  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEunsignedsPintgR);
5662  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEunsignedsPintgR);
5663  return &instance;
5664  }
5665  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<unsigned int>*)
5666  {
5667  return GenerateInitInstanceLocal((::NTuple::Matrix<unsigned int>*)0);
5668  }
5669  // Static variable to force the class initialization
5670  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5671 
5672  // Dictionary for non-ClassDef classes
5673  static TClass *NTuplecLcLMatrixlEunsignedsPintgR_Dictionary() {
5674  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<unsigned int>*)0x0)->GetClass();
5675  NTuplecLcLMatrixlEunsignedsPintgR_TClassManip(theClass);
5676  return theClass;
5677  }
5678 
5679  static void NTuplecLcLMatrixlEunsignedsPintgR_TClassManip(TClass* ){
5680  }
5681 
5682 } // end of namespace ROOT
5683 
5684 namespace ROOT {
5685  static TClass *NTuplecLcLMatrixlEfloatgR_Dictionary();
5686  static void NTuplecLcLMatrixlEfloatgR_TClassManip(TClass*);
5687  static void *new_NTuplecLcLMatrixlEfloatgR(void *p = 0);
5688  static void *newArray_NTuplecLcLMatrixlEfloatgR(Long_t size, void *p);
5689  static void delete_NTuplecLcLMatrixlEfloatgR(void *p);
5690  static void deleteArray_NTuplecLcLMatrixlEfloatgR(void *p);
5691  static void destruct_NTuplecLcLMatrixlEfloatgR(void *p);
5692 
5693  // Function generating the singleton type initializer
5694  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<float>*)
5695  {
5696  ::NTuple::Matrix<float> *ptr = 0;
5697  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<float>));
5698  static ::ROOT::TGenericClassInfo
5699  instance("NTuple::Matrix<float>", "GaudiKernel/NTuple.h", 375,
5700  typeid(::NTuple::Matrix<float>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5701  &NTuplecLcLMatrixlEfloatgR_Dictionary, isa_proxy, 4,
5702  sizeof(::NTuple::Matrix<float>) );
5703  instance.SetNew(&new_NTuplecLcLMatrixlEfloatgR);
5704  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEfloatgR);
5705  instance.SetDelete(&delete_NTuplecLcLMatrixlEfloatgR);
5706  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEfloatgR);
5707  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEfloatgR);
5708  return &instance;
5709  }
5710  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<float>*)
5711  {
5712  return GenerateInitInstanceLocal((::NTuple::Matrix<float>*)0);
5713  }
5714  // Static variable to force the class initialization
5715  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<float>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5716 
5717  // Dictionary for non-ClassDef classes
5718  static TClass *NTuplecLcLMatrixlEfloatgR_Dictionary() {
5719  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<float>*)0x0)->GetClass();
5720  NTuplecLcLMatrixlEfloatgR_TClassManip(theClass);
5721  return theClass;
5722  }
5723 
5724  static void NTuplecLcLMatrixlEfloatgR_TClassManip(TClass* ){
5725  }
5726 
5727 } // end of namespace ROOT
5728 
5729 namespace ROOT {
5730  static TClass *NTuplecLcLMatrixlEdoublegR_Dictionary();
5731  static void NTuplecLcLMatrixlEdoublegR_TClassManip(TClass*);
5732  static void *new_NTuplecLcLMatrixlEdoublegR(void *p = 0);
5733  static void *newArray_NTuplecLcLMatrixlEdoublegR(Long_t size, void *p);
5734  static void delete_NTuplecLcLMatrixlEdoublegR(void *p);
5735  static void deleteArray_NTuplecLcLMatrixlEdoublegR(void *p);
5736  static void destruct_NTuplecLcLMatrixlEdoublegR(void *p);
5737 
5738  // Function generating the singleton type initializer
5739  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<double>*)
5740  {
5741  ::NTuple::Matrix<double> *ptr = 0;
5742  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<double>));
5743  static ::ROOT::TGenericClassInfo
5744  instance("NTuple::Matrix<double>", "GaudiKernel/NTuple.h", 375,
5745  typeid(::NTuple::Matrix<double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5746  &NTuplecLcLMatrixlEdoublegR_Dictionary, isa_proxy, 4,
5747  sizeof(::NTuple::Matrix<double>) );
5748  instance.SetNew(&new_NTuplecLcLMatrixlEdoublegR);
5749  instance.SetNewArray(&newArray_NTuplecLcLMatrixlEdoublegR);
5750  instance.SetDelete(&delete_NTuplecLcLMatrixlEdoublegR);
5751  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEdoublegR);
5752  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEdoublegR);
5753  return &instance;
5754  }
5755  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<double>*)
5756  {
5757  return GenerateInitInstanceLocal((::NTuple::Matrix<double>*)0);
5758  }
5759  // Static variable to force the class initialization
5760  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<double>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5761 
5762  // Dictionary for non-ClassDef classes
5763  static TClass *NTuplecLcLMatrixlEdoublegR_Dictionary() {
5764  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<double>*)0x0)->GetClass();
5765  NTuplecLcLMatrixlEdoublegR_TClassManip(theClass);
5766  return theClass;
5767  }
5768 
5769  static void NTuplecLcLMatrixlEdoublegR_TClassManip(TClass* ){
5770  }
5771 
5772 } // end of namespace ROOT
5773 
5774 namespace ROOT {
5775  static TClass *NTuplecLcLItemlEboolgR_Dictionary();
5776  static void NTuplecLcLItemlEboolgR_TClassManip(TClass*);
5777  static void *new_NTuplecLcLItemlEboolgR(void *p = 0);
5778  static void *newArray_NTuplecLcLItemlEboolgR(Long_t size, void *p);
5779  static void delete_NTuplecLcLItemlEboolgR(void *p);
5780  static void deleteArray_NTuplecLcLItemlEboolgR(void *p);
5781  static void destruct_NTuplecLcLItemlEboolgR(void *p);
5782 
5783  // Function generating the singleton type initializer
5784  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Item<bool>*)
5785  {
5786  ::NTuple::Item<bool> *ptr = 0;
5787  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Item<bool>));
5788  static ::ROOT::TGenericClassInfo
5789  instance("NTuple::Item<bool>", "GaudiKernel/NTuple.h", 316,
5790  typeid(::NTuple::Item<bool>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5791  &NTuplecLcLItemlEboolgR_Dictionary, isa_proxy, 4,
5792  sizeof(::NTuple::Item<bool>) );
5793  instance.SetNew(&new_NTuplecLcLItemlEboolgR);
5794  instance.SetNewArray(&newArray_NTuplecLcLItemlEboolgR);
5795  instance.SetDelete(&delete_NTuplecLcLItemlEboolgR);
5796  instance.SetDeleteArray(&deleteArray_NTuplecLcLItemlEboolgR);
5797  instance.SetDestructor(&destruct_NTuplecLcLItemlEboolgR);
5798  return &instance;
5799  }
5800  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Item<bool>*)
5801  {
5802  return GenerateInitInstanceLocal((::NTuple::Item<bool>*)0);
5803  }
5804  // Static variable to force the class initialization
5805  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Item<bool>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5806 
5807  // Dictionary for non-ClassDef classes
5808  static TClass *NTuplecLcLItemlEboolgR_Dictionary() {
5809  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Item<bool>*)0x0)->GetClass();
5810  NTuplecLcLItemlEboolgR_TClassManip(theClass);
5811  return theClass;
5812  }
5813 
5814  static void NTuplecLcLItemlEboolgR_TClassManip(TClass* ){
5815  }
5816 
5817 } // end of namespace ROOT
5818 
5819 namespace ROOT {
5820  static TClass *NTuplecLcLDirectory_Dictionary();
5821  static void NTuplecLcLDirectory_TClassManip(TClass*);
5822  static void *new_NTuplecLcLDirectory(void *p = 0);
5823  static void *newArray_NTuplecLcLDirectory(Long_t size, void *p);
5824  static void delete_NTuplecLcLDirectory(void *p);
5825  static void deleteArray_NTuplecLcLDirectory(void *p);
5826  static void destruct_NTuplecLcLDirectory(void *p);
5827 
5828  // Function generating the singleton type initializer
5829  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Directory*)
5830  {
5831  ::NTuple::Directory *ptr = 0;
5832  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Directory));
5833  static ::ROOT::TGenericClassInfo
5834  instance("NTuple::Directory", "GaudiKernel/NTuple.h", 978,
5835  typeid(::NTuple::Directory), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5836  &NTuplecLcLDirectory_Dictionary, isa_proxy, 4,
5837  sizeof(::NTuple::Directory) );
5838  instance.SetNew(&new_NTuplecLcLDirectory);
5839  instance.SetNewArray(&newArray_NTuplecLcLDirectory);
5840  instance.SetDelete(&delete_NTuplecLcLDirectory);
5841  instance.SetDeleteArray(&deleteArray_NTuplecLcLDirectory);
5842  instance.SetDestructor(&destruct_NTuplecLcLDirectory);
5843  return &instance;
5844  }
5845  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Directory*)
5846  {
5847  return GenerateInitInstanceLocal((::NTuple::Directory*)0);
5848  }
5849  // Static variable to force the class initialization
5850  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Directory*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5851 
5852  // Dictionary for non-ClassDef classes
5853  static TClass *NTuplecLcLDirectory_Dictionary() {
5854  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Directory*)0x0)->GetClass();
5855  NTuplecLcLDirectory_TClassManip(theClass);
5856  return theClass;
5857  }
5858 
5859  static void NTuplecLcLDirectory_TClassManip(TClass* theClass){
5860  theClass->CreateAttributeMap();
5861  TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
5862  attrMap->AddProperty("id","00000029-0000-0000-0000-000000000000");
5863  }
5864 
5865 } // end of namespace ROOT
5866 
5867 namespace ROOT {
5868  static TClass *NTuplecLcLFile_Dictionary();
5869  static void NTuplecLcLFile_TClassManip(TClass*);
5870  static void *new_NTuplecLcLFile(void *p = 0);
5871  static void *newArray_NTuplecLcLFile(Long_t size, void *p);
5872  static void delete_NTuplecLcLFile(void *p);
5873  static void deleteArray_NTuplecLcLFile(void *p);
5874  static void destruct_NTuplecLcLFile(void *p);
5875 
5876  // Function generating the singleton type initializer
5877  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::File*)
5878  {
5879  ::NTuple::File *ptr = 0;
5880  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::File));
5881  static ::ROOT::TGenericClassInfo
5882  instance("NTuple::File", "GaudiKernel/NTuple.h", 987,
5883  typeid(::NTuple::File), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5884  &NTuplecLcLFile_Dictionary, isa_proxy, 4,
5885  sizeof(::NTuple::File) );
5886  instance.SetNew(&new_NTuplecLcLFile);
5887  instance.SetNewArray(&newArray_NTuplecLcLFile);
5888  instance.SetDelete(&delete_NTuplecLcLFile);
5889  instance.SetDeleteArray(&deleteArray_NTuplecLcLFile);
5890  instance.SetDestructor(&destruct_NTuplecLcLFile);
5891  return &instance;
5892  }
5893  TGenericClassInfo *GenerateInitInstance(const ::NTuple::File*)
5894  {
5895  return GenerateInitInstanceLocal((::NTuple::File*)0);
5896  }
5897  // Static variable to force the class initialization
5898  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::File*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5899 
5900  // Dictionary for non-ClassDef classes
5901  static TClass *NTuplecLcLFile_Dictionary() {
5902  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::File*)0x0)->GetClass();
5903  NTuplecLcLFile_TClassManip(theClass);
5904  return theClass;
5905  }
5906 
5907  static void NTuplecLcLFile_TClassManip(TClass* theClass){
5908  theClass->CreateAttributeMap();
5909  TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
5910  attrMap->AddProperty("id","00000028-0000-0000-0000-000000000000");
5911  }
5912 
5913 } // end of namespace ROOT
5914 
5915 namespace ROOT {
5916  static TClass *NTuplecLcLArraylEIOpaqueAddressmUgR_Dictionary();
5917  static void NTuplecLcLArraylEIOpaqueAddressmUgR_TClassManip(TClass*);
5918  static void delete_NTuplecLcLArraylEIOpaqueAddressmUgR(void *p);
5919  static void deleteArray_NTuplecLcLArraylEIOpaqueAddressmUgR(void *p);
5920  static void destruct_NTuplecLcLArraylEIOpaqueAddressmUgR(void *p);
5921 
5922  // Function generating the singleton type initializer
5923  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Array<IOpaqueAddress*>*)
5924  {
5925  ::NTuple::Array<IOpaqueAddress*> *ptr = 0;
5926  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Array<IOpaqueAddress*>));
5927  static ::ROOT::TGenericClassInfo
5928  instance("NTuple::Array<IOpaqueAddress*>", "GaudiKernel/NTuple.h", 1032,
5929  typeid(::NTuple::Array<IOpaqueAddress*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5930  &NTuplecLcLArraylEIOpaqueAddressmUgR_Dictionary, isa_proxy, 4,
5931  sizeof(::NTuple::Array<IOpaqueAddress*>) );
5932  instance.SetDelete(&delete_NTuplecLcLArraylEIOpaqueAddressmUgR);
5933  instance.SetDeleteArray(&deleteArray_NTuplecLcLArraylEIOpaqueAddressmUgR);
5934  instance.SetDestructor(&destruct_NTuplecLcLArraylEIOpaqueAddressmUgR);
5935  return &instance;
5936  }
5937  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Array<IOpaqueAddress*>*)
5938  {
5939  return GenerateInitInstanceLocal((::NTuple::Array<IOpaqueAddress*>*)0);
5940  }
5941  // Static variable to force the class initialization
5942  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Array<IOpaqueAddress*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5943 
5944  // Dictionary for non-ClassDef classes
5945  static TClass *NTuplecLcLArraylEIOpaqueAddressmUgR_Dictionary() {
5946  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Array<IOpaqueAddress*>*)0x0)->GetClass();
5947  NTuplecLcLArraylEIOpaqueAddressmUgR_TClassManip(theClass);
5948  return theClass;
5949  }
5950 
5951  static void NTuplecLcLArraylEIOpaqueAddressmUgR_TClassManip(TClass* ){
5952  }
5953 
5954 } // end of namespace ROOT
5955 
5956 namespace ROOT {
5957  static TClass *NTuplecLcLMatrixlEIOpaqueAddressmUgR_Dictionary();
5958  static void NTuplecLcLMatrixlEIOpaqueAddressmUgR_TClassManip(TClass*);
5959  static void delete_NTuplecLcLMatrixlEIOpaqueAddressmUgR(void *p);
5960  static void deleteArray_NTuplecLcLMatrixlEIOpaqueAddressmUgR(void *p);
5961  static void destruct_NTuplecLcLMatrixlEIOpaqueAddressmUgR(void *p);
5962 
5963  // Function generating the singleton type initializer
5964  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::Matrix<IOpaqueAddress*>*)
5965  {
5966  ::NTuple::Matrix<IOpaqueAddress*> *ptr = 0;
5967  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::Matrix<IOpaqueAddress*>));
5968  static ::ROOT::TGenericClassInfo
5969  instance("NTuple::Matrix<IOpaqueAddress*>", "GaudiKernel/NTuple.h", 1041,
5970  typeid(::NTuple::Matrix<IOpaqueAddress*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5971  &NTuplecLcLMatrixlEIOpaqueAddressmUgR_Dictionary, isa_proxy, 4,
5972  sizeof(::NTuple::Matrix<IOpaqueAddress*>) );
5973  instance.SetDelete(&delete_NTuplecLcLMatrixlEIOpaqueAddressmUgR);
5974  instance.SetDeleteArray(&deleteArray_NTuplecLcLMatrixlEIOpaqueAddressmUgR);
5975  instance.SetDestructor(&destruct_NTuplecLcLMatrixlEIOpaqueAddressmUgR);
5976  return &instance;
5977  }
5978  TGenericClassInfo *GenerateInitInstance(const ::NTuple::Matrix<IOpaqueAddress*>*)
5979  {
5980  return GenerateInitInstanceLocal((::NTuple::Matrix<IOpaqueAddress*>*)0);
5981  }
5982  // Static variable to force the class initialization
5983  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::Matrix<IOpaqueAddress*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5984 
5985  // Dictionary for non-ClassDef classes
5986  static TClass *NTuplecLcLMatrixlEIOpaqueAddressmUgR_Dictionary() {
5987  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::Matrix<IOpaqueAddress*>*)0x0)->GetClass();
5988  NTuplecLcLMatrixlEIOpaqueAddressmUgR_TClassManip(theClass);
5989  return theClass;
5990  }
5991 
5992  static void NTuplecLcLMatrixlEIOpaqueAddressmUgR_TClassManip(TClass* ){
5993  }
5994 
5995 } // end of namespace ROOT
5996 
5997 namespace ROOT {
5998  static TClass *NTuplecLcLColumnWiseTuple_Dictionary();
5999  static void NTuplecLcLColumnWiseTuple_TClassManip(TClass*);
6000  static void delete_NTuplecLcLColumnWiseTuple(void *p);
6001  static void deleteArray_NTuplecLcLColumnWiseTuple(void *p);
6002  static void destruct_NTuplecLcLColumnWiseTuple(void *p);
6003 
6004  // Function generating the singleton type initializer
6005  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::ColumnWiseTuple*)
6006  {
6007  ::NTuple::ColumnWiseTuple *ptr = 0;
6008  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::ColumnWiseTuple));
6009  static ::ROOT::TGenericClassInfo
6010  instance("NTuple::ColumnWiseTuple", "GaudiKernel/NTupleImplementation.h", 99,
6011  typeid(::NTuple::ColumnWiseTuple), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6012  &NTuplecLcLColumnWiseTuple_Dictionary, isa_proxy, 4,
6013  sizeof(::NTuple::ColumnWiseTuple) );
6014  instance.SetDelete(&delete_NTuplecLcLColumnWiseTuple);
6015  instance.SetDeleteArray(&deleteArray_NTuplecLcLColumnWiseTuple);
6016  instance.SetDestructor(&destruct_NTuplecLcLColumnWiseTuple);
6017  return &instance;
6018  }
6019  TGenericClassInfo *GenerateInitInstance(const ::NTuple::ColumnWiseTuple*)
6020  {
6021  return GenerateInitInstanceLocal((::NTuple::ColumnWiseTuple*)0);
6022  }
6023  // Static variable to force the class initialization
6024  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::ColumnWiseTuple*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6025 
6026  // Dictionary for non-ClassDef classes
6027  static TClass *NTuplecLcLColumnWiseTuple_Dictionary() {
6028  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::ColumnWiseTuple*)0x0)->GetClass();
6029  NTuplecLcLColumnWiseTuple_TClassManip(theClass);
6030  return theClass;
6031  }
6032 
6033  static void NTuplecLcLColumnWiseTuple_TClassManip(TClass* theClass){
6034  theClass->CreateAttributeMap();
6035  TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
6036  attrMap->AddProperty("id","0000002B-0000-0000-0000-000000000000");
6037  }
6038 
6039 } // end of namespace ROOT
6040 
6041 namespace ROOT {
6042  static TClass *NTuplecLcLRowWiseTuple_Dictionary();
6043  static void NTuplecLcLRowWiseTuple_TClassManip(TClass*);
6044  static void delete_NTuplecLcLRowWiseTuple(void *p);
6045  static void deleteArray_NTuplecLcLRowWiseTuple(void *p);
6046  static void destruct_NTuplecLcLRowWiseTuple(void *p);
6047 
6048  // Function generating the singleton type initializer
6049  static TGenericClassInfo *GenerateInitInstanceLocal(const ::NTuple::RowWiseTuple*)
6050  {
6051  ::NTuple::RowWiseTuple *ptr = 0;
6052  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::NTuple::RowWiseTuple));
6053  static ::ROOT::TGenericClassInfo
6054  instance("NTuple::RowWiseTuple", "GaudiKernel/NTupleImplementation.h", 111,
6055  typeid(::NTuple::RowWiseTuple), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6056  &NTuplecLcLRowWiseTuple_Dictionary, isa_proxy, 4,
6057  sizeof(::NTuple::RowWiseTuple) );
6058  instance.SetDelete(&delete_NTuplecLcLRowWiseTuple);
6059  instance.SetDeleteArray(&deleteArray_NTuplecLcLRowWiseTuple);
6060  instance.SetDestructor(&destruct_NTuplecLcLRowWiseTuple);
6061  return &instance;
6062  }
6063  TGenericClassInfo *GenerateInitInstance(const ::NTuple::RowWiseTuple*)
6064  {
6065  return GenerateInitInstanceLocal((::NTuple::RowWiseTuple*)0);
6066  }
6067  // Static variable to force the class initialization
6068  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NTuple::RowWiseTuple*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6069 
6070  // Dictionary for non-ClassDef classes
6071  static TClass *NTuplecLcLRowWiseTuple_Dictionary() {
6072  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::NTuple::RowWiseTuple*)0x0)->GetClass();
6073  NTuplecLcLRowWiseTuple_TClassManip(theClass);
6074  return theClass;
6075  }
6076 
6077  static void NTuplecLcLRowWiseTuple_TClassManip(TClass* theClass){
6078  theClass->CreateAttributeMap();
6079  TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
6080  attrMap->AddProperty("id","0000002A-0000-0000-0000-000000000000");
6081  }
6082 
6083 } // end of namespace ROOT
6084 
6085 namespace ROOT {
6086  static TClass *IRegistry_Dictionary();
6087  static void IRegistry_TClassManip(TClass*);
6088  static void delete_IRegistry(void *p);
6089  static void deleteArray_IRegistry(void *p);
6090  static void destruct_IRegistry(void *p);
6091 
6092  // Function generating the singleton type initializer
6093  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IRegistry*)
6094  {
6095  ::IRegistry *ptr = 0;
6096  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IRegistry));
6097  static ::ROOT::TGenericClassInfo
6098  instance("IRegistry", "GaudiKernel/IRegistry.h", 22,
6099  typeid(::IRegistry), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6100  &IRegistry_Dictionary, isa_proxy, 4,
6101  sizeof(::IRegistry) );
6102  instance.SetDelete(&delete_IRegistry);
6103  instance.SetDeleteArray(&deleteArray_IRegistry);
6104  instance.SetDestructor(&destruct_IRegistry);
6105  return &instance;
6106  }
6107  TGenericClassInfo *GenerateInitInstance(const ::IRegistry*)
6108  {
6109  return GenerateInitInstanceLocal((::IRegistry*)0);
6110  }
6111  // Static variable to force the class initialization
6112  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IRegistry*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6113 
6114  // Dictionary for non-ClassDef classes
6115  static TClass *IRegistry_Dictionary() {
6116  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IRegistry*)0x0)->GetClass();
6117  IRegistry_TClassManip(theClass);
6118  return theClass;
6119  }
6120 
6121  static void IRegistry_TClassManip(TClass* ){
6122  }
6123 
6124 } // end of namespace ROOT
6125 
6126 namespace ROOT {
6127  static TClass *RndmcLcLGauss_Dictionary();
6128  static void RndmcLcLGauss_TClassManip(TClass*);
6129  static void delete_RndmcLcLGauss(void *p);
6130  static void deleteArray_RndmcLcLGauss(void *p);
6131  static void destruct_RndmcLcLGauss(void *p);
6132 
6133  // Function generating the singleton type initializer
6134  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Gauss*)
6135  {
6136  ::Rndm::Gauss *ptr = 0;
6137  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Gauss));
6138  static ::ROOT::TGenericClassInfo
6139  instance("Rndm::Gauss", "GaudiKernel/RndmGenerators.h", 23,
6140  typeid(::Rndm::Gauss), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6141  &RndmcLcLGauss_Dictionary, isa_proxy, 4,
6142  sizeof(::Rndm::Gauss) );
6143  instance.SetDelete(&delete_RndmcLcLGauss);
6144  instance.SetDeleteArray(&deleteArray_RndmcLcLGauss);
6145  instance.SetDestructor(&destruct_RndmcLcLGauss);
6146  return &instance;
6147  }
6148  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Gauss*)
6149  {
6150  return GenerateInitInstanceLocal((::Rndm::Gauss*)0);
6151  }
6152  // Static variable to force the class initialization
6153  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Gauss*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6154 
6155  // Dictionary for non-ClassDef classes
6156  static TClass *RndmcLcLGauss_Dictionary() {
6157  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Gauss*)0x0)->GetClass();
6158  RndmcLcLGauss_TClassManip(theClass);
6159  return theClass;
6160  }
6161 
6162  static void RndmcLcLGauss_TClassManip(TClass* ){
6163  }
6164 
6165 } // end of namespace ROOT
6166 
6167 namespace ROOT {
6168  static TClass *RndmcLcLExponential_Dictionary();
6169  static void RndmcLcLExponential_TClassManip(TClass*);
6170  static void delete_RndmcLcLExponential(void *p);
6171  static void deleteArray_RndmcLcLExponential(void *p);
6172  static void destruct_RndmcLcLExponential(void *p);
6173 
6174  // Function generating the singleton type initializer
6175  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Exponential*)
6176  {
6177  ::Rndm::Exponential *ptr = 0;
6178  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Exponential));
6179  static ::ROOT::TGenericClassInfo
6180  instance("Rndm::Exponential", "GaudiKernel/RndmGenerators.h", 48,
6181  typeid(::Rndm::Exponential), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6182  &RndmcLcLExponential_Dictionary, isa_proxy, 4,
6183  sizeof(::Rndm::Exponential) );
6184  instance.SetDelete(&delete_RndmcLcLExponential);
6185  instance.SetDeleteArray(&deleteArray_RndmcLcLExponential);
6186  instance.SetDestructor(&destruct_RndmcLcLExponential);
6187  return &instance;
6188  }
6189  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Exponential*)
6190  {
6191  return GenerateInitInstanceLocal((::Rndm::Exponential*)0);
6192  }
6193  // Static variable to force the class initialization
6194  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Exponential*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6195 
6196  // Dictionary for non-ClassDef classes
6197  static TClass *RndmcLcLExponential_Dictionary() {
6198  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Exponential*)0x0)->GetClass();
6199  RndmcLcLExponential_TClassManip(theClass);
6200  return theClass;
6201  }
6202 
6203  static void RndmcLcLExponential_TClassManip(TClass* ){
6204  }
6205 
6206 } // end of namespace ROOT
6207 
6208 namespace ROOT {
6209  static TClass *RndmcLcLChi2_Dictionary();
6210  static void RndmcLcLChi2_TClassManip(TClass*);
6211  static void delete_RndmcLcLChi2(void *p);
6212  static void deleteArray_RndmcLcLChi2(void *p);
6213  static void destruct_RndmcLcLChi2(void *p);
6214 
6215  // Function generating the singleton type initializer
6216  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Chi2*)
6217  {
6218  ::Rndm::Chi2 *ptr = 0;
6219  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Chi2));
6220  static ::ROOT::TGenericClassInfo
6221  instance("Rndm::Chi2", "GaudiKernel/RndmGenerators.h", 67,
6222  typeid(::Rndm::Chi2), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6223  &RndmcLcLChi2_Dictionary, isa_proxy, 4,
6224  sizeof(::Rndm::Chi2) );
6225  instance.SetDelete(&delete_RndmcLcLChi2);
6226  instance.SetDeleteArray(&deleteArray_RndmcLcLChi2);
6227  instance.SetDestructor(&destruct_RndmcLcLChi2);
6228  return &instance;
6229  }
6230  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Chi2*)
6231  {
6232  return GenerateInitInstanceLocal((::Rndm::Chi2*)0);
6233  }
6234  // Static variable to force the class initialization
6235  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Chi2*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6236 
6237  // Dictionary for non-ClassDef classes
6238  static TClass *RndmcLcLChi2_Dictionary() {
6239  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Chi2*)0x0)->GetClass();
6240  RndmcLcLChi2_TClassManip(theClass);
6241  return theClass;
6242  }
6243 
6244  static void RndmcLcLChi2_TClassManip(TClass* ){
6245  }
6246 
6247 } // end of namespace ROOT
6248 
6249 namespace ROOT {
6250  static TClass *RndmcLcLBreitWigner_Dictionary();
6251  static void RndmcLcLBreitWigner_TClassManip(TClass*);
6252  static void delete_RndmcLcLBreitWigner(void *p);
6253  static void deleteArray_RndmcLcLBreitWigner(void *p);
6254  static void destruct_RndmcLcLBreitWigner(void *p);
6255 
6256  // Function generating the singleton type initializer
6257  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::BreitWigner*)
6258  {
6259  ::Rndm::BreitWigner *ptr = 0;
6260  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::BreitWigner));
6261  static ::ROOT::TGenericClassInfo
6262  instance("Rndm::BreitWigner", "GaudiKernel/RndmGenerators.h", 88,
6263  typeid(::Rndm::BreitWigner), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6264  &RndmcLcLBreitWigner_Dictionary, isa_proxy, 4,
6265  sizeof(::Rndm::BreitWigner) );
6266  instance.SetDelete(&delete_RndmcLcLBreitWigner);
6267  instance.SetDeleteArray(&deleteArray_RndmcLcLBreitWigner);
6268  instance.SetDestructor(&destruct_RndmcLcLBreitWigner);
6269  return &instance;
6270  }
6271  TGenericClassInfo *GenerateInitInstance(const ::Rndm::BreitWigner*)
6272  {
6273  return GenerateInitInstanceLocal((::Rndm::BreitWigner*)0);
6274  }
6275  // Static variable to force the class initialization
6276  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::BreitWigner*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6277 
6278  // Dictionary for non-ClassDef classes
6279  static TClass *RndmcLcLBreitWigner_Dictionary() {
6280  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::BreitWigner*)0x0)->GetClass();
6281  RndmcLcLBreitWigner_TClassManip(theClass);
6282  return theClass;
6283  }
6284 
6285  static void RndmcLcLBreitWigner_TClassManip(TClass* ){
6286  }
6287 
6288 } // end of namespace ROOT
6289 
6290 namespace ROOT {
6291  static TClass *RndmcLcLLandau_Dictionary();
6292  static void RndmcLcLLandau_TClassManip(TClass*);
6293  static void delete_RndmcLcLLandau(void *p);
6294  static void deleteArray_RndmcLcLLandau(void *p);
6295  static void destruct_RndmcLcLLandau(void *p);
6296 
6297  // Function generating the singleton type initializer
6298  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Landau*)
6299  {
6300  ::Rndm::Landau *ptr = 0;
6301  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Landau));
6302  static ::ROOT::TGenericClassInfo
6303  instance("Rndm::Landau", "GaudiKernel/RndmGenerators.h", 111,
6304  typeid(::Rndm::Landau), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6305  &RndmcLcLLandau_Dictionary, isa_proxy, 4,
6306  sizeof(::Rndm::Landau) );
6307  instance.SetDelete(&delete_RndmcLcLLandau);
6308  instance.SetDeleteArray(&deleteArray_RndmcLcLLandau);
6309  instance.SetDestructor(&destruct_RndmcLcLLandau);
6310  return &instance;
6311  }
6312  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Landau*)
6313  {
6314  return GenerateInitInstanceLocal((::Rndm::Landau*)0);
6315  }
6316  // Static variable to force the class initialization
6317  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Landau*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6318 
6319  // Dictionary for non-ClassDef classes
6320  static TClass *RndmcLcLLandau_Dictionary() {
6321  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Landau*)0x0)->GetClass();
6322  RndmcLcLLandau_TClassManip(theClass);
6323  return theClass;
6324  }
6325 
6326  static void RndmcLcLLandau_TClassManip(TClass* ){
6327  }
6328 
6329 } // end of namespace ROOT
6330 
6331 namespace ROOT {
6332  static TClass *RndmcLcLBreitWignerCutOff_Dictionary();
6333  static void RndmcLcLBreitWignerCutOff_TClassManip(TClass*);
6334  static void delete_RndmcLcLBreitWignerCutOff(void *p);
6335  static void deleteArray_RndmcLcLBreitWignerCutOff(void *p);
6336  static void destruct_RndmcLcLBreitWignerCutOff(void *p);
6337 
6338  // Function generating the singleton type initializer
6339  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::BreitWignerCutOff*)
6340  {
6341  ::Rndm::BreitWignerCutOff *ptr = 0;
6342  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::BreitWignerCutOff));
6343  static ::ROOT::TGenericClassInfo
6344  instance("Rndm::BreitWignerCutOff", "GaudiKernel/RndmGenerators.h", 135,
6345  typeid(::Rndm::BreitWignerCutOff), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6346  &RndmcLcLBreitWignerCutOff_Dictionary, isa_proxy, 4,
6347  sizeof(::Rndm::BreitWignerCutOff) );
6348  instance.SetDelete(&delete_RndmcLcLBreitWignerCutOff);
6349  instance.SetDeleteArray(&deleteArray_RndmcLcLBreitWignerCutOff);
6350  instance.SetDestructor(&destruct_RndmcLcLBreitWignerCutOff);
6351  return &instance;
6352  }
6353  TGenericClassInfo *GenerateInitInstance(const ::Rndm::BreitWignerCutOff*)
6354  {
6355  return GenerateInitInstanceLocal((::Rndm::BreitWignerCutOff*)0);
6356  }
6357  // Static variable to force the class initialization
6358  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::BreitWignerCutOff*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6359 
6360  // Dictionary for non-ClassDef classes
6361  static TClass *RndmcLcLBreitWignerCutOff_Dictionary() {
6362  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::BreitWignerCutOff*)0x0)->GetClass();
6363  RndmcLcLBreitWignerCutOff_TClassManip(theClass);
6364  return theClass;
6365  }
6366 
6367  static void RndmcLcLBreitWignerCutOff_TClassManip(TClass* ){
6368  }
6369 
6370 } // end of namespace ROOT
6371 
6372 namespace ROOT {
6373  static TClass *RndmcLcLStudentT_Dictionary();
6374  static void RndmcLcLStudentT_TClassManip(TClass*);
6375  static void delete_RndmcLcLStudentT(void *p);
6376  static void deleteArray_RndmcLcLStudentT(void *p);
6377  static void destruct_RndmcLcLStudentT(void *p);
6378 
6379  // Function generating the singleton type initializer
6380  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::StudentT*)
6381  {
6382  ::Rndm::StudentT *ptr = 0;
6383  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::StudentT));
6384  static ::ROOT::TGenericClassInfo
6385  instance("Rndm::StudentT", "GaudiKernel/RndmGenerators.h", 163,
6386  typeid(::Rndm::StudentT), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6387  &RndmcLcLStudentT_Dictionary, isa_proxy, 4,
6388  sizeof(::Rndm::StudentT) );
6389  instance.SetDelete(&delete_RndmcLcLStudentT);
6390  instance.SetDeleteArray(&deleteArray_RndmcLcLStudentT);
6391  instance.SetDestructor(&destruct_RndmcLcLStudentT);
6392  return &instance;
6393  }
6394  TGenericClassInfo *GenerateInitInstance(const ::Rndm::StudentT*)
6395  {
6396  return GenerateInitInstanceLocal((::Rndm::StudentT*)0);
6397  }
6398  // Static variable to force the class initialization
6399  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::StudentT*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6400 
6401  // Dictionary for non-ClassDef classes
6402  static TClass *RndmcLcLStudentT_Dictionary() {
6403  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::StudentT*)0x0)->GetClass();
6404  RndmcLcLStudentT_TClassManip(theClass);
6405  return theClass;
6406  }
6407 
6408  static void RndmcLcLStudentT_TClassManip(TClass* ){
6409  }
6410 
6411 } // end of namespace ROOT
6412 
6413 namespace ROOT {
6414  static TClass *RndmcLcLGamma_Dictionary();
6415  static void RndmcLcLGamma_TClassManip(TClass*);
6416  static void delete_RndmcLcLGamma(void *p);
6417  static void deleteArray_RndmcLcLGamma(void *p);
6418  static void destruct_RndmcLcLGamma(void *p);
6419 
6420  // Function generating the singleton type initializer
6421  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Gamma*)
6422  {
6423  ::Rndm::Gamma *ptr = 0;
6424  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Gamma));
6425  static ::ROOT::TGenericClassInfo
6426  instance("Rndm::Gamma", "GaudiKernel/RndmGenerators.h", 184,
6427  typeid(::Rndm::Gamma), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6428  &RndmcLcLGamma_Dictionary, isa_proxy, 4,
6429  sizeof(::Rndm::Gamma) );
6430  instance.SetDelete(&delete_RndmcLcLGamma);
6431  instance.SetDeleteArray(&deleteArray_RndmcLcLGamma);
6432  instance.SetDestructor(&destruct_RndmcLcLGamma);
6433  return &instance;
6434  }
6435  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Gamma*)
6436  {
6437  return GenerateInitInstanceLocal((::Rndm::Gamma*)0);
6438  }
6439  // Static variable to force the class initialization
6440  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Gamma*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6441 
6442  // Dictionary for non-ClassDef classes
6443  static TClass *RndmcLcLGamma_Dictionary() {
6444  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Gamma*)0x0)->GetClass();
6445  RndmcLcLGamma_TClassManip(theClass);
6446  return theClass;
6447  }
6448 
6449  static void RndmcLcLGamma_TClassManip(TClass* ){
6450  }
6451 
6452 } // end of namespace ROOT
6453 
6454 namespace ROOT {
6455  static TClass *RndmcLcLPoisson_Dictionary();
6456  static void RndmcLcLPoisson_TClassManip(TClass*);
6457  static void delete_RndmcLcLPoisson(void *p);
6458  static void deleteArray_RndmcLcLPoisson(void *p);
6459  static void destruct_RndmcLcLPoisson(void *p);
6460 
6461  // Function generating the singleton type initializer
6462  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Poisson*)
6463  {
6464  ::Rndm::Poisson *ptr = 0;
6465  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Poisson));
6466  static ::ROOT::TGenericClassInfo
6467  instance("Rndm::Poisson", "GaudiKernel/RndmGenerators.h", 210,
6468  typeid(::Rndm::Poisson), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6469  &RndmcLcLPoisson_Dictionary, isa_proxy, 4,
6470  sizeof(::Rndm::Poisson) );
6471  instance.SetDelete(&delete_RndmcLcLPoisson);
6472  instance.SetDeleteArray(&deleteArray_RndmcLcLPoisson);
6473  instance.SetDestructor(&destruct_RndmcLcLPoisson);
6474  return &instance;
6475  }
6476  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Poisson*)
6477  {
6478  return GenerateInitInstanceLocal((::Rndm::Poisson*)0);
6479  }
6480  // Static variable to force the class initialization
6481  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Poisson*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6482 
6483  // Dictionary for non-ClassDef classes
6484  static TClass *RndmcLcLPoisson_Dictionary() {
6485  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Poisson*)0x0)->GetClass();
6486  RndmcLcLPoisson_TClassManip(theClass);
6487  return theClass;
6488  }
6489 
6490  static void RndmcLcLPoisson_TClassManip(TClass* ){
6491  }
6492 
6493 } // end of namespace ROOT
6494 
6495 namespace ROOT {
6496  static TClass *RndmcLcLBinomial_Dictionary();
6497  static void RndmcLcLBinomial_TClassManip(TClass*);
6498  static void delete_RndmcLcLBinomial(void *p);
6499  static void deleteArray_RndmcLcLBinomial(void *p);
6500  static void destruct_RndmcLcLBinomial(void *p);
6501 
6502  // Function generating the singleton type initializer
6503  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Binomial*)
6504  {
6505  ::Rndm::Binomial *ptr = 0;
6506  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Binomial));
6507  static ::ROOT::TGenericClassInfo
6508  instance("Rndm::Binomial", "GaudiKernel/RndmGenerators.h", 232,
6509  typeid(::Rndm::Binomial), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6510  &RndmcLcLBinomial_Dictionary, isa_proxy, 4,
6511  sizeof(::Rndm::Binomial) );
6512  instance.SetDelete(&delete_RndmcLcLBinomial);
6513  instance.SetDeleteArray(&deleteArray_RndmcLcLBinomial);
6514  instance.SetDestructor(&destruct_RndmcLcLBinomial);
6515  return &instance;
6516  }
6517  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Binomial*)
6518  {
6519  return GenerateInitInstanceLocal((::Rndm::Binomial*)0);
6520  }
6521  // Static variable to force the class initialization
6522  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Binomial*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6523 
6524  // Dictionary for non-ClassDef classes
6525  static TClass *RndmcLcLBinomial_Dictionary() {
6526  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Binomial*)0x0)->GetClass();
6527  RndmcLcLBinomial_TClassManip(theClass);
6528  return theClass;
6529  }
6530 
6531  static void RndmcLcLBinomial_TClassManip(TClass* ){
6532  }
6533 
6534 } // end of namespace ROOT
6535 
6536 namespace ROOT {
6537  static TClass *RndmcLcLFlat_Dictionary();
6538  static void RndmcLcLFlat_TClassManip(TClass*);
6539  static void delete_RndmcLcLFlat(void *p);
6540  static void deleteArray_RndmcLcLFlat(void *p);
6541  static void destruct_RndmcLcLFlat(void *p);
6542 
6543  // Function generating the singleton type initializer
6544  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Flat*)
6545  {
6546  ::Rndm::Flat *ptr = 0;
6547  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Flat));
6548  static ::ROOT::TGenericClassInfo
6549  instance("Rndm::Flat", "GaudiKernel/RndmGenerators.h", 256,
6550  typeid(::Rndm::Flat), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6551  &RndmcLcLFlat_Dictionary, isa_proxy, 4,
6552  sizeof(::Rndm::Flat) );
6553  instance.SetDelete(&delete_RndmcLcLFlat);
6554  instance.SetDeleteArray(&deleteArray_RndmcLcLFlat);
6555  instance.SetDestructor(&destruct_RndmcLcLFlat);
6556  return &instance;
6557  }
6558  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Flat*)
6559  {
6560  return GenerateInitInstanceLocal((::Rndm::Flat*)0);
6561  }
6562  // Static variable to force the class initialization
6563  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Flat*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6564 
6565  // Dictionary for non-ClassDef classes
6566  static TClass *RndmcLcLFlat_Dictionary() {
6567  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Flat*)0x0)->GetClass();
6568  RndmcLcLFlat_TClassManip(theClass);
6569  return theClass;
6570  }
6571 
6572  static void RndmcLcLFlat_TClassManip(TClass* ){
6573  }
6574 
6575 } // end of namespace ROOT
6576 
6577 namespace ROOT {
6578  static TClass *RndmcLcLBit_Dictionary();
6579  static void RndmcLcLBit_TClassManip(TClass*);
6580  static void *new_RndmcLcLBit(void *p = 0);
6581  static void *newArray_RndmcLcLBit(Long_t size, void *p);
6582  static void delete_RndmcLcLBit(void *p);
6583  static void deleteArray_RndmcLcLBit(void *p);
6584  static void destruct_RndmcLcLBit(void *p);
6585 
6586  // Function generating the singleton type initializer
6587  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Bit*)
6588  {
6589  ::Rndm::Bit *ptr = 0;
6590  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Bit));
6591  static ::ROOT::TGenericClassInfo
6592  instance("Rndm::Bit", "GaudiKernel/RndmGenerators.h", 279,
6593  typeid(::Rndm::Bit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6594  &RndmcLcLBit_Dictionary, isa_proxy, 4,
6595  sizeof(::Rndm::Bit) );
6596  instance.SetNew(&new_RndmcLcLBit);
6597  instance.SetNewArray(&newArray_RndmcLcLBit);
6598  instance.SetDelete(&delete_RndmcLcLBit);
6599  instance.SetDeleteArray(&deleteArray_RndmcLcLBit);
6600  instance.SetDestructor(&destruct_RndmcLcLBit);
6601  return &instance;
6602  }
6603  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Bit*)
6604  {
6605  return GenerateInitInstanceLocal((::Rndm::Bit*)0);
6606  }
6607  // Static variable to force the class initialization
6608  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Bit*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6609 
6610  // Dictionary for non-ClassDef classes
6611  static TClass *RndmcLcLBit_Dictionary() {
6612  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Bit*)0x0)->GetClass();
6613  RndmcLcLBit_TClassManip(theClass);
6614  return theClass;
6615  }
6616 
6617  static void RndmcLcLBit_TClassManip(TClass* ){
6618  }
6619 
6620 } // end of namespace ROOT
6621 
6622 namespace ROOT {
6623  static TClass *RndmcLcLDefinedPdf_Dictionary();
6624  static void RndmcLcLDefinedPdf_TClassManip(TClass*);
6625  static void delete_RndmcLcLDefinedPdf(void *p);
6626  static void deleteArray_RndmcLcLDefinedPdf(void *p);
6627  static void destruct_RndmcLcLDefinedPdf(void *p);
6628 
6629  // Function generating the singleton type initializer
6630  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::DefinedPdf*)
6631  {
6632  ::Rndm::DefinedPdf *ptr = 0;
6633  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::DefinedPdf));
6634  static ::ROOT::TGenericClassInfo
6635  instance("Rndm::DefinedPdf", "GaudiKernel/RndmGenerators.h", 306,
6636  typeid(::Rndm::DefinedPdf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6637  &RndmcLcLDefinedPdf_Dictionary, isa_proxy, 4,
6638  sizeof(::Rndm::DefinedPdf) );
6639  instance.SetDelete(&delete_RndmcLcLDefinedPdf);
6640  instance.SetDeleteArray(&deleteArray_RndmcLcLDefinedPdf);
6641  instance.SetDestructor(&destruct_RndmcLcLDefinedPdf);
6642  return &instance;
6643  }
6644  TGenericClassInfo *GenerateInitInstance(const ::Rndm::DefinedPdf*)
6645  {
6646  return GenerateInitInstanceLocal((::Rndm::DefinedPdf*)0);
6647  }
6648  // Static variable to force the class initialization
6649  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::DefinedPdf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6650 
6651  // Dictionary for non-ClassDef classes
6652  static TClass *RndmcLcLDefinedPdf_Dictionary() {
6653  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::DefinedPdf*)0x0)->GetClass();
6654  RndmcLcLDefinedPdf_TClassManip(theClass);
6655  return theClass;
6656  }
6657 
6658  static void RndmcLcLDefinedPdf_TClassManip(TClass* ){
6659  }
6660 
6661 } // end of namespace ROOT
6662 
6663 namespace ROOT {
6664  static TClass *RndmcLcLGaussianTail_Dictionary();
6665  static void RndmcLcLGaussianTail_TClassManip(TClass*);
6666  static void delete_RndmcLcLGaussianTail(void *p);
6667  static void deleteArray_RndmcLcLGaussianTail(void *p);
6668  static void destruct_RndmcLcLGaussianTail(void *p);
6669 
6670  // Function generating the singleton type initializer
6671  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::GaussianTail*)
6672  {
6673  ::Rndm::GaussianTail *ptr = 0;
6674  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::GaussianTail));
6675  static ::ROOT::TGenericClassInfo
6676  instance("Rndm::GaussianTail", "GaudiKernel/RndmGenerators.h", 332,
6677  typeid(::Rndm::GaussianTail), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6678  &RndmcLcLGaussianTail_Dictionary, isa_proxy, 4,
6679  sizeof(::Rndm::GaussianTail) );
6680  instance.SetDelete(&delete_RndmcLcLGaussianTail);
6681  instance.SetDeleteArray(&deleteArray_RndmcLcLGaussianTail);
6682  instance.SetDestructor(&destruct_RndmcLcLGaussianTail);
6683  return &instance;
6684  }
6685  TGenericClassInfo *GenerateInitInstance(const ::Rndm::GaussianTail*)
6686  {
6687  return GenerateInitInstanceLocal((::Rndm::GaussianTail*)0);
6688  }
6689  // Static variable to force the class initialization
6690  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::GaussianTail*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6691 
6692  // Dictionary for non-ClassDef classes
6693  static TClass *RndmcLcLGaussianTail_Dictionary() {
6694  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::GaussianTail*)0x0)->GetClass();
6695  RndmcLcLGaussianTail_TClassManip(theClass);
6696  return theClass;
6697  }
6698 
6699  static void RndmcLcLGaussianTail_TClassManip(TClass* ){
6700  }
6701 
6702 } // end of namespace ROOT
6703 
6704 namespace ROOT {
6705  static TClass *RndmcLcLNumbers_Dictionary();
6706  static void RndmcLcLNumbers_TClassManip(TClass*);
6707  static void *new_RndmcLcLNumbers(void *p = 0);
6708  static void *newArray_RndmcLcLNumbers(Long_t size, void *p);
6709  static void delete_RndmcLcLNumbers(void *p);
6710  static void deleteArray_RndmcLcLNumbers(void *p);
6711  static void destruct_RndmcLcLNumbers(void *p);
6712 
6713  // Function generating the singleton type initializer
6714  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Rndm::Numbers*)
6715  {
6716  ::Rndm::Numbers *ptr = 0;
6717  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Rndm::Numbers));
6718  static ::ROOT::TGenericClassInfo
6719  instance("Rndm::Numbers", "GaudiKernel/RndmGenerators.h", 368,
6720  typeid(::Rndm::Numbers), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6721  &RndmcLcLNumbers_Dictionary, isa_proxy, 4,
6722  sizeof(::Rndm::Numbers) );
6723  instance.SetNew(&new_RndmcLcLNumbers);
6724  instance.SetNewArray(&newArray_RndmcLcLNumbers);
6725  instance.SetDelete(&delete_RndmcLcLNumbers);
6726  instance.SetDeleteArray(&deleteArray_RndmcLcLNumbers);
6727  instance.SetDestructor(&destruct_RndmcLcLNumbers);
6728  return &instance;
6729  }
6730  TGenericClassInfo *GenerateInitInstance(const ::Rndm::Numbers*)
6731  {
6732  return GenerateInitInstanceLocal((::Rndm::Numbers*)0);
6733  }
6734  // Static variable to force the class initialization
6735  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Rndm::Numbers*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6736 
6737  // Dictionary for non-ClassDef classes
6738  static TClass *RndmcLcLNumbers_Dictionary() {
6739  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Rndm::Numbers*)0x0)->GetClass();
6740  RndmcLcLNumbers_TClassManip(theClass);
6741  return theClass;
6742  }
6743 
6744  static void RndmcLcLNumbers_TClassManip(TClass* ){
6745  }
6746 
6747 } // end of namespace ROOT
6748 
6749 namespace ROOT {
6750  static TClass *SmartRefVectorlEDataObjectgR_Dictionary();
6751  static void SmartRefVectorlEDataObjectgR_TClassManip(TClass*);
6752  static void *new_SmartRefVectorlEDataObjectgR(void *p = 0);
6753  static void *newArray_SmartRefVectorlEDataObjectgR(Long_t size, void *p);
6754  static void delete_SmartRefVectorlEDataObjectgR(void *p);
6755  static void deleteArray_SmartRefVectorlEDataObjectgR(void *p);
6756  static void destruct_SmartRefVectorlEDataObjectgR(void *p);
6757 
6758  // Function generating the singleton type initializer
6759  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<DataObject>*)
6760  {
6761  ::SmartRefVector<DataObject> *ptr = 0;
6762  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<DataObject>));
6763  static ::ROOT::TGenericClassInfo
6764  instance("SmartRefVector<DataObject>", "GaudiKernel/SmartRefVector.h", 55,
6765  typeid(::SmartRefVector<DataObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6766  &SmartRefVectorlEDataObjectgR_Dictionary, isa_proxy, 4,
6767  sizeof(::SmartRefVector<DataObject>) );
6768  instance.SetNew(&new_SmartRefVectorlEDataObjectgR);
6769  instance.SetNewArray(&newArray_SmartRefVectorlEDataObjectgR);
6770  instance.SetDelete(&delete_SmartRefVectorlEDataObjectgR);
6771  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEDataObjectgR);
6772  instance.SetDestructor(&destruct_SmartRefVectorlEDataObjectgR);
6773  return &instance;
6774  }
6775  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<DataObject>*)
6776  {
6777  return GenerateInitInstanceLocal((::SmartRefVector<DataObject>*)0);
6778  }
6779  // Static variable to force the class initialization
6780  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<DataObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6781 
6782  // Dictionary for non-ClassDef classes
6783  static TClass *SmartRefVectorlEDataObjectgR_Dictionary() {
6784  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<DataObject>*)0x0)->GetClass();
6785  SmartRefVectorlEDataObjectgR_TClassManip(theClass);
6786  return theClass;
6787  }
6788 
6789  static void SmartRefVectorlEDataObjectgR_TClassManip(TClass* ){
6790  }
6791 
6792 } // end of namespace ROOT
6793 
6794 namespace ROOT {
6795  static TClass *SmartRefVectorlEContainedObjectgR_Dictionary();
6796  static void SmartRefVectorlEContainedObjectgR_TClassManip(TClass*);
6797  static void *new_SmartRefVectorlEContainedObjectgR(void *p = 0);
6798  static void *newArray_SmartRefVectorlEContainedObjectgR(Long_t size, void *p);
6799  static void delete_SmartRefVectorlEContainedObjectgR(void *p);
6800  static void deleteArray_SmartRefVectorlEContainedObjectgR(void *p);
6801  static void destruct_SmartRefVectorlEContainedObjectgR(void *p);
6802 
6803  // Function generating the singleton type initializer
6804  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<ContainedObject>*)
6805  {
6806  ::SmartRefVector<ContainedObject> *ptr = 0;
6807  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<ContainedObject>));
6808  static ::ROOT::TGenericClassInfo
6809  instance("SmartRefVector<ContainedObject>", "GaudiKernel/SmartRefVector.h", 55,
6810  typeid(::SmartRefVector<ContainedObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6811  &SmartRefVectorlEContainedObjectgR_Dictionary, isa_proxy, 4,
6812  sizeof(::SmartRefVector<ContainedObject>) );
6813  instance.SetNew(&new_SmartRefVectorlEContainedObjectgR);
6814  instance.SetNewArray(&newArray_SmartRefVectorlEContainedObjectgR);
6815  instance.SetDelete(&delete_SmartRefVectorlEContainedObjectgR);
6816  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEContainedObjectgR);
6817  instance.SetDestructor(&destruct_SmartRefVectorlEContainedObjectgR);
6818  return &instance;
6819  }
6820  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<ContainedObject>*)
6821  {
6822  return GenerateInitInstanceLocal((::SmartRefVector<ContainedObject>*)0);
6823  }
6824  // Static variable to force the class initialization
6825  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<ContainedObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6826 
6827  // Dictionary for non-ClassDef classes
6828  static TClass *SmartRefVectorlEContainedObjectgR_Dictionary() {
6829  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<ContainedObject>*)0x0)->GetClass();
6830  SmartRefVectorlEContainedObjectgR_TClassManip(theClass);
6831  return theClass;
6832  }
6833 
6834  static void SmartRefVectorlEContainedObjectgR_TClassManip(TClass* ){
6835  }
6836 
6837 } // end of namespace ROOT
6838 
6839 namespace ROOT {
6840  static TClass *SmartRefVectorlEObjectContainerBasegR_Dictionary();
6841  static void SmartRefVectorlEObjectContainerBasegR_TClassManip(TClass*);
6842  static void *new_SmartRefVectorlEObjectContainerBasegR(void *p = 0);
6843  static void *newArray_SmartRefVectorlEObjectContainerBasegR(Long_t size, void *p);
6844  static void delete_SmartRefVectorlEObjectContainerBasegR(void *p);
6845  static void deleteArray_SmartRefVectorlEObjectContainerBasegR(void *p);
6846  static void destruct_SmartRefVectorlEObjectContainerBasegR(void *p);
6847 
6848  // Function generating the singleton type initializer
6849  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<ObjectContainerBase>*)
6850  {
6851  ::SmartRefVector<ObjectContainerBase> *ptr = 0;
6852  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<ObjectContainerBase>));
6853  static ::ROOT::TGenericClassInfo
6854  instance("SmartRefVector<ObjectContainerBase>", "GaudiKernel/SmartRefVector.h", 55,
6855  typeid(::SmartRefVector<ObjectContainerBase>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6856  &SmartRefVectorlEObjectContainerBasegR_Dictionary, isa_proxy, 4,
6857  sizeof(::SmartRefVector<ObjectContainerBase>) );
6858  instance.SetNew(&new_SmartRefVectorlEObjectContainerBasegR);
6859  instance.SetNewArray(&newArray_SmartRefVectorlEObjectContainerBasegR);
6860  instance.SetDelete(&delete_SmartRefVectorlEObjectContainerBasegR);
6861  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEObjectContainerBasegR);
6862  instance.SetDestructor(&destruct_SmartRefVectorlEObjectContainerBasegR);
6863  return &instance;
6864  }
6865  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<ObjectContainerBase>*)
6866  {
6867  return GenerateInitInstanceLocal((::SmartRefVector<ObjectContainerBase>*)0);
6868  }
6869  // Static variable to force the class initialization
6870  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<ObjectContainerBase>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6871 
6872  // Dictionary for non-ClassDef classes
6873  static TClass *SmartRefVectorlEObjectContainerBasegR_Dictionary() {
6874  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<ObjectContainerBase>*)0x0)->GetClass();
6875  SmartRefVectorlEObjectContainerBasegR_TClassManip(theClass);
6876  return theClass;
6877  }
6878 
6879  static void SmartRefVectorlEObjectContainerBasegR_TClassManip(TClass* ){
6880  }
6881 
6882 } // end of namespace ROOT
6883 
6884 namespace ROOT {
6885  static TClass *SmartRefVectorlEKeyedObjectlEintgRsPgR_Dictionary();
6886  static void SmartRefVectorlEKeyedObjectlEintgRsPgR_TClassManip(TClass*);
6887  static void *new_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p = 0);
6888  static void *newArray_SmartRefVectorlEKeyedObjectlEintgRsPgR(Long_t size, void *p);
6889  static void delete_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p);
6890  static void deleteArray_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p);
6891  static void destruct_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p);
6892 
6893  // Function generating the singleton type initializer
6894  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<KeyedObject<int> >*)
6895  {
6896  ::SmartRefVector<KeyedObject<int> > *ptr = 0;
6897  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<KeyedObject<int> >));
6898  static ::ROOT::TGenericClassInfo
6899  instance("SmartRefVector<KeyedObject<int> >", "GaudiKernel/SmartRefVector.h", 55,
6900  typeid(::SmartRefVector<KeyedObject<int> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6901  &SmartRefVectorlEKeyedObjectlEintgRsPgR_Dictionary, isa_proxy, 4,
6902  sizeof(::SmartRefVector<KeyedObject<int> >) );
6903  instance.SetNew(&new_SmartRefVectorlEKeyedObjectlEintgRsPgR);
6904  instance.SetNewArray(&newArray_SmartRefVectorlEKeyedObjectlEintgRsPgR);
6905  instance.SetDelete(&delete_SmartRefVectorlEKeyedObjectlEintgRsPgR);
6906  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEKeyedObjectlEintgRsPgR);
6907  instance.SetDestructor(&destruct_SmartRefVectorlEKeyedObjectlEintgRsPgR);
6908  return &instance;
6909  }
6910  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<KeyedObject<int> >*)
6911  {
6912  return GenerateInitInstanceLocal((::SmartRefVector<KeyedObject<int> >*)0);
6913  }
6914  // Static variable to force the class initialization
6915  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<int> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6916 
6917  // Dictionary for non-ClassDef classes
6918  static TClass *SmartRefVectorlEKeyedObjectlEintgRsPgR_Dictionary() {
6919  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<int> >*)0x0)->GetClass();
6920  SmartRefVectorlEKeyedObjectlEintgRsPgR_TClassManip(theClass);
6921  return theClass;
6922  }
6923 
6924  static void SmartRefVectorlEKeyedObjectlEintgRsPgR_TClassManip(TClass* ){
6925  }
6926 
6927 } // end of namespace ROOT
6928 
6929 namespace ROOT {
6930  static TClass *SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR_Dictionary();
6931  static void SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR_TClassManip(TClass*);
6932  static void *new_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p = 0);
6933  static void *newArray_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(Long_t size, void *p);
6934  static void delete_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p);
6935  static void deleteArray_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p);
6936  static void destruct_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p);
6937 
6938  // Function generating the singleton type initializer
6939  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<KeyedObject<unsigned int> >*)
6940  {
6941  ::SmartRefVector<KeyedObject<unsigned int> > *ptr = 0;
6942  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<KeyedObject<unsigned int> >));
6943  static ::ROOT::TGenericClassInfo
6944  instance("SmartRefVector<KeyedObject<unsigned int> >", "GaudiKernel/SmartRefVector.h", 55,
6945  typeid(::SmartRefVector<KeyedObject<unsigned int> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6946  &SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR_Dictionary, isa_proxy, 4,
6947  sizeof(::SmartRefVector<KeyedObject<unsigned int> >) );
6948  instance.SetNew(&new_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR);
6949  instance.SetNewArray(&newArray_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR);
6950  instance.SetDelete(&delete_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR);
6951  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR);
6952  instance.SetDestructor(&destruct_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR);
6953  return &instance;
6954  }
6955  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<KeyedObject<unsigned int> >*)
6956  {
6957  return GenerateInitInstanceLocal((::SmartRefVector<KeyedObject<unsigned int> >*)0);
6958  }
6959  // Static variable to force the class initialization
6960  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<unsigned int> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6961 
6962  // Dictionary for non-ClassDef classes
6963  static TClass *SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR_Dictionary() {
6964  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<unsigned int> >*)0x0)->GetClass();
6965  SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR_TClassManip(theClass);
6966  return theClass;
6967  }
6968 
6969  static void SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR_TClassManip(TClass* ){
6970  }
6971 
6972 } // end of namespace ROOT
6973 
6974 namespace ROOT {
6975  static TClass *SmartRefVectorlEKeyedObjectlElonggRsPgR_Dictionary();
6976  static void SmartRefVectorlEKeyedObjectlElonggRsPgR_TClassManip(TClass*);
6977  static void *new_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p = 0);
6978  static void *newArray_SmartRefVectorlEKeyedObjectlElonggRsPgR(Long_t size, void *p);
6979  static void delete_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p);
6980  static void deleteArray_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p);
6981  static void destruct_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p);
6982 
6983  // Function generating the singleton type initializer
6984  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<KeyedObject<long> >*)
6985  {
6986  ::SmartRefVector<KeyedObject<long> > *ptr = 0;
6987  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<KeyedObject<long> >));
6988  static ::ROOT::TGenericClassInfo
6989  instance("SmartRefVector<KeyedObject<long> >", "GaudiKernel/SmartRefVector.h", 55,
6990  typeid(::SmartRefVector<KeyedObject<long> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6991  &SmartRefVectorlEKeyedObjectlElonggRsPgR_Dictionary, isa_proxy, 4,
6992  sizeof(::SmartRefVector<KeyedObject<long> >) );
6993  instance.SetNew(&new_SmartRefVectorlEKeyedObjectlElonggRsPgR);
6994  instance.SetNewArray(&newArray_SmartRefVectorlEKeyedObjectlElonggRsPgR);
6995  instance.SetDelete(&delete_SmartRefVectorlEKeyedObjectlElonggRsPgR);
6996  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEKeyedObjectlElonggRsPgR);
6997  instance.SetDestructor(&destruct_SmartRefVectorlEKeyedObjectlElonggRsPgR);
6998  return &instance;
6999  }
7000  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<KeyedObject<long> >*)
7001  {
7002  return GenerateInitInstanceLocal((::SmartRefVector<KeyedObject<long> >*)0);
7003  }
7004  // Static variable to force the class initialization
7005  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<long> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7006 
7007  // Dictionary for non-ClassDef classes
7008  static TClass *SmartRefVectorlEKeyedObjectlElonggRsPgR_Dictionary() {
7009  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<long> >*)0x0)->GetClass();
7010  SmartRefVectorlEKeyedObjectlElonggRsPgR_TClassManip(theClass);
7011  return theClass;
7012  }
7013 
7014  static void SmartRefVectorlEKeyedObjectlElonggRsPgR_TClassManip(TClass* ){
7015  }
7016 
7017 } // end of namespace ROOT
7018 
7019 namespace ROOT {
7020  static TClass *SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR_Dictionary();
7021  static void SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR_TClassManip(TClass*);
7022  static void *new_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p = 0);
7023  static void *newArray_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(Long_t size, void *p);
7024  static void delete_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p);
7025  static void deleteArray_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p);
7026  static void destruct_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p);
7027 
7028  // Function generating the singleton type initializer
7029  static TGenericClassInfo *GenerateInitInstanceLocal(const ::SmartRefVector<KeyedObject<unsigned long> >*)
7030  {
7031  ::SmartRefVector<KeyedObject<unsigned long> > *ptr = 0;
7032  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SmartRefVector<KeyedObject<unsigned long> >));
7033  static ::ROOT::TGenericClassInfo
7034  instance("SmartRefVector<KeyedObject<unsigned long> >", "GaudiKernel/SmartRefVector.h", 55,
7035  typeid(::SmartRefVector<KeyedObject<unsigned long> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7036  &SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR_Dictionary, isa_proxy, 4,
7037  sizeof(::SmartRefVector<KeyedObject<unsigned long> >) );
7038  instance.SetNew(&new_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR);
7039  instance.SetNewArray(&newArray_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR);
7040  instance.SetDelete(&delete_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR);
7041  instance.SetDeleteArray(&deleteArray_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR);
7042  instance.SetDestructor(&destruct_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR);
7043  return &instance;
7044  }
7045  TGenericClassInfo *GenerateInitInstance(const ::SmartRefVector<KeyedObject<unsigned long> >*)
7046  {
7047  return GenerateInitInstanceLocal((::SmartRefVector<KeyedObject<unsigned long> >*)0);
7048  }
7049  // Static variable to force the class initialization
7050  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<unsigned long> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7051 
7052  // Dictionary for non-ClassDef classes
7053  static TClass *SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR_Dictionary() {
7054  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SmartRefVector<KeyedObject<unsigned long> >*)0x0)->GetClass();
7055  SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR_TClassManip(theClass);
7056  return theClass;
7057  }
7058 
7059  static void SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR_TClassManip(TClass* ){
7060  }
7061 
7062 } // end of namespace ROOT
7063 
7064 namespace ROOT {
7065  static TClass *GaudicLcLTime_Dictionary();
7066  static void GaudicLcLTime_TClassManip(TClass*);
7067  static void *new_GaudicLcLTime(void *p = 0);
7068  static void *newArray_GaudicLcLTime(Long_t size, void *p);
7069  static void delete_GaudicLcLTime(void *p);
7070  static void deleteArray_GaudicLcLTime(void *p);
7071  static void destruct_GaudicLcLTime(void *p);
7072 
7073  // Function generating the singleton type initializer
7074  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Time*)
7075  {
7076  ::Gaudi::Time *ptr = 0;
7077  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Time));
7078  static ::ROOT::TGenericClassInfo
7079  instance("Gaudi::Time", "GaudiKernel/Time.h", 237,
7080  typeid(::Gaudi::Time), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7081  &GaudicLcLTime_Dictionary, isa_proxy, 4,
7082  sizeof(::Gaudi::Time) );
7083  instance.SetNew(&new_GaudicLcLTime);
7084  instance.SetNewArray(&newArray_GaudicLcLTime);
7085  instance.SetDelete(&delete_GaudicLcLTime);
7086  instance.SetDeleteArray(&deleteArray_GaudicLcLTime);
7087  instance.SetDestructor(&destruct_GaudicLcLTime);
7088  return &instance;
7089  }
7090  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Time*)
7091  {
7092  return GenerateInitInstanceLocal((::Gaudi::Time*)0);
7093  }
7094  // Static variable to force the class initialization
7095  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Time*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7096 
7097  // Dictionary for non-ClassDef classes
7098  static TClass *GaudicLcLTime_Dictionary() {
7099  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Time*)0x0)->GetClass();
7100  GaudicLcLTime_TClassManip(theClass);
7101  return theClass;
7102  }
7103 
7104  static void GaudicLcLTime_TClassManip(TClass* ){
7105  }
7106 
7107 } // end of namespace ROOT
7108 
7109 namespace ROOT {
7110  static TClass *DataObjectHandleBase_Dictionary();
7111  static void DataObjectHandleBase_TClassManip(TClass*);
7112  static void delete_DataObjectHandleBase(void *p);
7113  static void deleteArray_DataObjectHandleBase(void *p);
7114  static void destruct_DataObjectHandleBase(void *p);
7115 
7116  // Function generating the singleton type initializer
7117  static TGenericClassInfo *GenerateInitInstanceLocal(const ::DataObjectHandleBase*)
7118  {
7119  ::DataObjectHandleBase *ptr = 0;
7120  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::DataObjectHandleBase));
7121  static ::ROOT::TGenericClassInfo
7122  instance("DataObjectHandleBase", "GaudiKernel/DataObjectHandleBase.h", 26,
7123  typeid(::DataObjectHandleBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7124  &DataObjectHandleBase_Dictionary, isa_proxy, 4,
7125  sizeof(::DataObjectHandleBase) );
7126  instance.SetDelete(&delete_DataObjectHandleBase);
7127  instance.SetDeleteArray(&deleteArray_DataObjectHandleBase);
7128  instance.SetDestructor(&destruct_DataObjectHandleBase);
7129  return &instance;
7130  }
7131  TGenericClassInfo *GenerateInitInstance(const ::DataObjectHandleBase*)
7132  {
7133  return GenerateInitInstanceLocal((::DataObjectHandleBase*)0);
7134  }
7135  // Static variable to force the class initialization
7136  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DataObjectHandleBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7137 
7138  // Dictionary for non-ClassDef classes
7139  static TClass *DataObjectHandleBase_Dictionary() {
7140  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::DataObjectHandleBase*)0x0)->GetClass();
7141  DataObjectHandleBase_TClassManip(theClass);
7142  return theClass;
7143  }
7144 
7145  static void DataObjectHandleBase_TClassManip(TClass* ){
7146  }
7147 
7148 } // end of namespace ROOT
7149 
7150 namespace ROOT {
7151  static TClass *IAddressCreator_Dictionary();
7152  static void IAddressCreator_TClassManip(TClass*);
7153  static void delete_IAddressCreator(void *p);
7154  static void deleteArray_IAddressCreator(void *p);
7155  static void destruct_IAddressCreator(void *p);
7156 
7157  // Function generating the singleton type initializer
7158  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAddressCreator*)
7159  {
7160  ::IAddressCreator *ptr = 0;
7161  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAddressCreator));
7162  static ::ROOT::TGenericClassInfo
7163  instance("IAddressCreator", "GaudiKernel/IAddressCreator.h", 28,
7164  typeid(::IAddressCreator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7165  &IAddressCreator_Dictionary, isa_proxy, 4,
7166  sizeof(::IAddressCreator) );
7167  instance.SetDelete(&delete_IAddressCreator);
7168  instance.SetDeleteArray(&deleteArray_IAddressCreator);
7169  instance.SetDestructor(&destruct_IAddressCreator);
7170  return &instance;
7171  }
7172  TGenericClassInfo *GenerateInitInstance(const ::IAddressCreator*)
7173  {
7174  return GenerateInitInstanceLocal((::IAddressCreator*)0);
7175  }
7176  // Static variable to force the class initialization
7177  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAddressCreator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7178 
7179  // Dictionary for non-ClassDef classes
7180  static TClass *IAddressCreator_Dictionary() {
7181  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAddressCreator*)0x0)->GetClass();
7182  IAddressCreator_TClassManip(theClass);
7183  return theClass;
7184  }
7185 
7186  static void IAddressCreator_TClassManip(TClass* ){
7187  }
7188 
7189 } // end of namespace ROOT
7190 
7191 namespace ROOT {
7192  static TClass *IAlgManager_Dictionary();
7193  static void IAlgManager_TClassManip(TClass*);
7194  static void delete_IAlgManager(void *p);
7195  static void deleteArray_IAlgManager(void *p);
7196  static void destruct_IAlgManager(void *p);
7197 
7198  // Function generating the singleton type initializer
7199  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAlgManager*)
7200  {
7201  ::IAlgManager *ptr = 0;
7202  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAlgManager));
7203  static ::ROOT::TGenericClassInfo
7204  instance("IAlgManager", "GaudiKernel/IAlgManager.h", 27,
7205  typeid(::IAlgManager), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7206  &IAlgManager_Dictionary, isa_proxy, 4,
7207  sizeof(::IAlgManager) );
7208  instance.SetDelete(&delete_IAlgManager);
7209  instance.SetDeleteArray(&deleteArray_IAlgManager);
7210  instance.SetDestructor(&destruct_IAlgManager);
7211  return &instance;
7212  }
7213  TGenericClassInfo *GenerateInitInstance(const ::IAlgManager*)
7214  {
7215  return GenerateInitInstanceLocal((::IAlgManager*)0);
7216  }
7217  // Static variable to force the class initialization
7218  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAlgManager*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7219 
7220  // Dictionary for non-ClassDef classes
7221  static TClass *IAlgManager_Dictionary() {
7222  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAlgManager*)0x0)->GetClass();
7223  IAlgManager_TClassManip(theClass);
7224  return theClass;
7225  }
7226 
7227  static void IAlgManager_TClassManip(TClass* ){
7228  }
7229 
7230 } // end of namespace ROOT
7231 
7232 namespace ROOT {
7233  static TClass *IAppMgrUI_Dictionary();
7234  static void IAppMgrUI_TClassManip(TClass*);
7235  static void delete_IAppMgrUI(void *p);
7236  static void deleteArray_IAppMgrUI(void *p);
7237  static void destruct_IAppMgrUI(void *p);
7238 
7239  // Function generating the singleton type initializer
7240  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IAppMgrUI*)
7241  {
7242  ::IAppMgrUI *ptr = 0;
7243  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IAppMgrUI));
7244  static ::ROOT::TGenericClassInfo
7245  instance("IAppMgrUI", "GaudiKernel/IAppMgrUI.h", 20,
7246  typeid(::IAppMgrUI), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7247  &IAppMgrUI_Dictionary, isa_proxy, 4,
7248  sizeof(::IAppMgrUI) );
7249  instance.SetDelete(&delete_IAppMgrUI);
7250  instance.SetDeleteArray(&deleteArray_IAppMgrUI);
7251  instance.SetDestructor(&destruct_IAppMgrUI);
7252  return &instance;
7253  }
7254  TGenericClassInfo *GenerateInitInstance(const ::IAppMgrUI*)
7255  {
7256  return GenerateInitInstanceLocal((::IAppMgrUI*)0);
7257  }
7258  // Static variable to force the class initialization
7259  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IAppMgrUI*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7260 
7261  // Dictionary for non-ClassDef classes
7262  static TClass *IAppMgrUI_Dictionary() {
7263  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IAppMgrUI*)0x0)->GetClass();
7264  IAppMgrUI_TClassManip(theClass);
7265  return theClass;
7266  }
7267 
7268  static void IAppMgrUI_TClassManip(TClass* ){
7269  }
7270 
7271 } // end of namespace ROOT
7272 
7273 namespace ROOT {
7274  static TClass *IClassInfo_Dictionary();
7275  static void IClassInfo_TClassManip(TClass*);
7276  static void delete_IClassInfo(void *p);
7277  static void deleteArray_IClassInfo(void *p);
7278  static void destruct_IClassInfo(void *p);
7279 
7280  // Function generating the singleton type initializer
7281  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IClassInfo*)
7282  {
7283  ::IClassInfo *ptr = 0;
7284  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IClassInfo));
7285  static ::ROOT::TGenericClassInfo
7286  instance("IClassInfo", "GaudiKernel/IClassInfo.h", 12,
7287  typeid(::IClassInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7288  &IClassInfo_Dictionary, isa_proxy, 4,
7289  sizeof(::IClassInfo) );
7290  instance.SetDelete(&delete_IClassInfo);
7291  instance.SetDeleteArray(&deleteArray_IClassInfo);
7292  instance.SetDestructor(&destruct_IClassInfo);
7293  return &instance;
7294  }
7295  TGenericClassInfo *GenerateInitInstance(const ::IClassInfo*)
7296  {
7297  return GenerateInitInstanceLocal((::IClassInfo*)0);
7298  }
7299  // Static variable to force the class initialization
7300  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IClassInfo*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7301 
7302  // Dictionary for non-ClassDef classes
7303  static TClass *IClassInfo_Dictionary() {
7304  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IClassInfo*)0x0)->GetClass();
7305  IClassInfo_TClassManip(theClass);
7306  return theClass;
7307  }
7308 
7309  static void IClassInfo_TClassManip(TClass* ){
7310  }
7311 
7312 } // end of namespace ROOT
7313 
7314 namespace ROOT {
7315  static TClass *IClassManager_Dictionary();
7316  static void IClassManager_TClassManip(TClass*);
7317  static void delete_IClassManager(void *p);
7318  static void deleteArray_IClassManager(void *p);
7319  static void destruct_IClassManager(void *p);
7320 
7321  // Function generating the singleton type initializer
7322  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IClassManager*)
7323  {
7324  ::IClassManager *ptr = 0;
7325  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IClassManager));
7326  static ::ROOT::TGenericClassInfo
7327  instance("IClassManager", "GaudiKernel/IClassManager.h", 18,
7328  typeid(::IClassManager), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7329  &IClassManager_Dictionary, isa_proxy, 4,
7330  sizeof(::IClassManager) );
7331  instance.SetDelete(&delete_IClassManager);
7332  instance.SetDeleteArray(&deleteArray_IClassManager);
7333  instance.SetDestructor(&destruct_IClassManager);
7334  return &instance;
7335  }
7336  TGenericClassInfo *GenerateInitInstance(const ::IClassManager*)
7337  {
7338  return GenerateInitInstanceLocal((::IClassManager*)0);
7339  }
7340  // Static variable to force the class initialization
7341  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IClassManager*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7342 
7343  // Dictionary for non-ClassDef classes
7344  static TClass *IClassManager_Dictionary() {
7345  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IClassManager*)0x0)->GetClass();
7346  IClassManager_TClassManip(theClass);
7347  return theClass;
7348  }
7349 
7350  static void IClassManager_TClassManip(TClass* ){
7351  }
7352 
7353 } // end of namespace ROOT
7354 
7355 namespace ROOT {
7356  static TClass *ICounterSummarySvc_Dictionary();
7357  static void ICounterSummarySvc_TClassManip(TClass*);
7358  static void delete_ICounterSummarySvc(void *p);
7359  static void deleteArray_ICounterSummarySvc(void *p);
7360  static void destruct_ICounterSummarySvc(void *p);
7361 
7362  // Function generating the singleton type initializer
7363  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ICounterSummarySvc*)
7364  {
7365  ::ICounterSummarySvc *ptr = 0;
7366  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ICounterSummarySvc));
7367  static ::ROOT::TGenericClassInfo
7368  instance("ICounterSummarySvc", "GaudiKernel/ICounterSummarySvc.h", 36,
7369  typeid(::ICounterSummarySvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7370  &ICounterSummarySvc_Dictionary, isa_proxy, 4,
7371  sizeof(::ICounterSummarySvc) );
7372  instance.SetDelete(&delete_ICounterSummarySvc);
7373  instance.SetDeleteArray(&deleteArray_ICounterSummarySvc);
7374  instance.SetDestructor(&destruct_ICounterSummarySvc);
7375  return &instance;
7376  }
7377  TGenericClassInfo *GenerateInitInstance(const ::ICounterSummarySvc*)
7378  {
7379  return GenerateInitInstanceLocal((::ICounterSummarySvc*)0);
7380  }
7381  // Static variable to force the class initialization
7382  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ICounterSummarySvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7383 
7384  // Dictionary for non-ClassDef classes
7385  static TClass *ICounterSummarySvc_Dictionary() {
7386  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ICounterSummarySvc*)0x0)->GetClass();
7387  ICounterSummarySvc_TClassManip(theClass);
7388  return theClass;
7389  }
7390 
7391  static void ICounterSummarySvc_TClassManip(TClass* ){
7392  }
7393 
7394 } // end of namespace ROOT
7395 
7396 namespace ROOT {
7397  static TClass *IDataManagerSvc_Dictionary();
7398  static void IDataManagerSvc_TClassManip(TClass*);
7399  static void delete_IDataManagerSvc(void *p);
7400  static void deleteArray_IDataManagerSvc(void *p);
7401  static void destruct_IDataManagerSvc(void *p);
7402 
7403  // Function generating the singleton type initializer
7404  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDataManagerSvc*)
7405  {
7406  ::IDataManagerSvc *ptr = 0;
7407  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDataManagerSvc));
7408  static ::ROOT::TGenericClassInfo
7409  instance("IDataManagerSvc", "GaudiKernel/IDataManagerSvc.h", 46,
7410  typeid(::IDataManagerSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7411  &IDataManagerSvc_Dictionary, isa_proxy, 4,
7412  sizeof(::IDataManagerSvc) );
7413  instance.SetDelete(&delete_IDataManagerSvc);
7414  instance.SetDeleteArray(&deleteArray_IDataManagerSvc);
7415  instance.SetDestructor(&destruct_IDataManagerSvc);
7416  return &instance;
7417  }
7418  TGenericClassInfo *GenerateInitInstance(const ::IDataManagerSvc*)
7419  {
7420  return GenerateInitInstanceLocal((::IDataManagerSvc*)0);
7421  }
7422  // Static variable to force the class initialization
7423  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDataManagerSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7424 
7425  // Dictionary for non-ClassDef classes
7426  static TClass *IDataManagerSvc_Dictionary() {
7427  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDataManagerSvc*)0x0)->GetClass();
7428  IDataManagerSvc_TClassManip(theClass);
7429  return theClass;
7430  }
7431 
7432  static void IDataManagerSvc_TClassManip(TClass* ){
7433  }
7434 
7435 } // end of namespace ROOT
7436 
7437 namespace ROOT {
7438  static TClass *IDataSourceMgr_Dictionary();
7439  static void IDataSourceMgr_TClassManip(TClass*);
7440  static void delete_IDataSourceMgr(void *p);
7441  static void deleteArray_IDataSourceMgr(void *p);
7442  static void destruct_IDataSourceMgr(void *p);
7443 
7444  // Function generating the singleton type initializer
7445  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDataSourceMgr*)
7446  {
7447  ::IDataSourceMgr *ptr = 0;
7448  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDataSourceMgr));
7449  static ::ROOT::TGenericClassInfo
7450  instance("IDataSourceMgr", "GaudiKernel/IDataSourceMgr.h", 14,
7451  typeid(::IDataSourceMgr), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7452  &IDataSourceMgr_Dictionary, isa_proxy, 4,
7453  sizeof(::IDataSourceMgr) );
7454  instance.SetDelete(&delete_IDataSourceMgr);
7455  instance.SetDeleteArray(&deleteArray_IDataSourceMgr);
7456  instance.SetDestructor(&destruct_IDataSourceMgr);
7457  return &instance;
7458  }
7459  TGenericClassInfo *GenerateInitInstance(const ::IDataSourceMgr*)
7460  {
7461  return GenerateInitInstanceLocal((::IDataSourceMgr*)0);
7462  }
7463  // Static variable to force the class initialization
7464  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDataSourceMgr*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7465 
7466  // Dictionary for non-ClassDef classes
7467  static TClass *IDataSourceMgr_Dictionary() {
7468  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDataSourceMgr*)0x0)->GetClass();
7469  IDataSourceMgr_TClassManip(theClass);
7470  return theClass;
7471  }
7472 
7473  static void IDataSourceMgr_TClassManip(TClass* ){
7474  }
7475 
7476 } // end of namespace ROOT
7477 
7478 namespace ROOT {
7479  static TClass *IDataStoreAgent_Dictionary();
7480  static void IDataStoreAgent_TClassManip(TClass*);
7481  static void delete_IDataStoreAgent(void *p);
7482  static void deleteArray_IDataStoreAgent(void *p);
7483  static void destruct_IDataStoreAgent(void *p);
7484 
7485  // Function generating the singleton type initializer
7486  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDataStoreAgent*)
7487  {
7488  ::IDataStoreAgent *ptr = 0;
7489  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDataStoreAgent));
7490  static ::ROOT::TGenericClassInfo
7491  instance("IDataStoreAgent", "GaudiKernel/IDataStoreAgent.h", 16,
7492  typeid(::IDataStoreAgent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7493  &IDataStoreAgent_Dictionary, isa_proxy, 4,
7494  sizeof(::IDataStoreAgent) );
7495  instance.SetDelete(&delete_IDataStoreAgent);
7496  instance.SetDeleteArray(&deleteArray_IDataStoreAgent);
7497  instance.SetDestructor(&destruct_IDataStoreAgent);
7498  return &instance;
7499  }
7500  TGenericClassInfo *GenerateInitInstance(const ::IDataStoreAgent*)
7501  {
7502  return GenerateInitInstanceLocal((::IDataStoreAgent*)0);
7503  }
7504  // Static variable to force the class initialization
7505  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDataStoreAgent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7506 
7507  // Dictionary for non-ClassDef classes
7508  static TClass *IDataStoreAgent_Dictionary() {
7509  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDataStoreAgent*)0x0)->GetClass();
7510  IDataStoreAgent_TClassManip(theClass);
7511  return theClass;
7512  }
7513 
7514  static void IDataStoreAgent_TClassManip(TClass* ){
7515  }
7516 
7517 } // end of namespace ROOT
7518 
7519 namespace ROOT {
7520  static TClass *IDataStoreLeaves_Dictionary();
7521  static void IDataStoreLeaves_TClassManip(TClass*);
7522  static void delete_IDataStoreLeaves(void *p);
7523  static void deleteArray_IDataStoreLeaves(void *p);
7524  static void destruct_IDataStoreLeaves(void *p);
7525 
7526  // Function generating the singleton type initializer
7527  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDataStoreLeaves*)
7528  {
7529  ::IDataStoreLeaves *ptr = 0;
7530  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDataStoreLeaves));
7531  static ::ROOT::TGenericClassInfo
7532  instance("IDataStoreLeaves", "GaudiKernel/IDataStoreLeaves.h", 15,
7533  typeid(::IDataStoreLeaves), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7534  &IDataStoreLeaves_Dictionary, isa_proxy, 4,
7535  sizeof(::IDataStoreLeaves) );
7536  instance.SetDelete(&delete_IDataStoreLeaves);
7537  instance.SetDeleteArray(&deleteArray_IDataStoreLeaves);
7538  instance.SetDestructor(&destruct_IDataStoreLeaves);
7539  return &instance;
7540  }
7541  TGenericClassInfo *GenerateInitInstance(const ::IDataStoreLeaves*)
7542  {
7543  return GenerateInitInstanceLocal((::IDataStoreLeaves*)0);
7544  }
7545  // Static variable to force the class initialization
7546  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDataStoreLeaves*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7547 
7548  // Dictionary for non-ClassDef classes
7549  static TClass *IDataStoreLeaves_Dictionary() {
7550  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDataStoreLeaves*)0x0)->GetClass();
7551  IDataStoreLeaves_TClassManip(theClass);
7552  return theClass;
7553  }
7554 
7555  static void IDataStoreLeaves_TClassManip(TClass* ){
7556  }
7557 
7558 } // end of namespace ROOT
7559 
7560 namespace ROOT {
7561  static TClass *IDetDataSvc_Dictionary();
7562  static void IDetDataSvc_TClassManip(TClass*);
7563  static void delete_IDetDataSvc(void *p);
7564  static void deleteArray_IDetDataSvc(void *p);
7565  static void destruct_IDetDataSvc(void *p);
7566 
7567  // Function generating the singleton type initializer
7568  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDetDataSvc*)
7569  {
7570  ::IDetDataSvc *ptr = 0;
7571  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IDetDataSvc));
7572  static ::ROOT::TGenericClassInfo
7573  instance("IDetDataSvc", "GaudiKernel/IDetDataSvc.h", 23,
7574  typeid(::IDetDataSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7575  &IDetDataSvc_Dictionary, isa_proxy, 4,
7576  sizeof(::IDetDataSvc) );
7577  instance.SetDelete(&delete_IDetDataSvc);
7578  instance.SetDeleteArray(&deleteArray_IDetDataSvc);
7579  instance.SetDestructor(&destruct_IDetDataSvc);
7580  return &instance;
7581  }
7582  TGenericClassInfo *GenerateInitInstance(const ::IDetDataSvc*)
7583  {
7584  return GenerateInitInstanceLocal((::IDetDataSvc*)0);
7585  }
7586  // Static variable to force the class initialization
7587  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IDetDataSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7588 
7589  // Dictionary for non-ClassDef classes
7590  static TClass *IDetDataSvc_Dictionary() {
7591  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IDetDataSvc*)0x0)->GetClass();
7592  IDetDataSvc_TClassManip(theClass);
7593  return theClass;
7594  }
7595 
7596  static void IDetDataSvc_TClassManip(TClass* ){
7597  }
7598 
7599 } // end of namespace ROOT
7600 
7601 namespace ROOT {
7602  static TClass *IEventProcessor_Dictionary();
7603  static void IEventProcessor_TClassManip(TClass*);
7604  static void delete_IEventProcessor(void *p);
7605  static void deleteArray_IEventProcessor(void *p);
7606  static void destruct_IEventProcessor(void *p);
7607 
7608  // Function generating the singleton type initializer
7609  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IEventProcessor*)
7610  {
7611  ::IEventProcessor *ptr = 0;
7612  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IEventProcessor));
7613  static ::ROOT::TGenericClassInfo
7614  instance("IEventProcessor", "GaudiKernel/IEventProcessor.h", 16,
7615  typeid(::IEventProcessor), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7616  &IEventProcessor_Dictionary, isa_proxy, 4,
7617  sizeof(::IEventProcessor) );
7618  instance.SetDelete(&delete_IEventProcessor);
7619  instance.SetDeleteArray(&deleteArray_IEventProcessor);
7620  instance.SetDestructor(&destruct_IEventProcessor);
7621  return &instance;
7622  }
7623  TGenericClassInfo *GenerateInitInstance(const ::IEventProcessor*)
7624  {
7625  return GenerateInitInstanceLocal((::IEventProcessor*)0);
7626  }
7627  // Static variable to force the class initialization
7628  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IEventProcessor*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7629 
7630  // Dictionary for non-ClassDef classes
7631  static TClass *IEventProcessor_Dictionary() {
7632  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IEventProcessor*)0x0)->GetClass();
7633  IEventProcessor_TClassManip(theClass);
7634  return theClass;
7635  }
7636 
7637  static void IEventProcessor_TClassManip(TClass* ){
7638  }
7639 
7640 } // end of namespace ROOT
7641 
7642 namespace ROOT {
7643  static TClass *IEventTimeDecoder_Dictionary();
7644  static void IEventTimeDecoder_TClassManip(TClass*);
7645  static void delete_IEventTimeDecoder(void *p);
7646  static void deleteArray_IEventTimeDecoder(void *p);
7647  static void destruct_IEventTimeDecoder(void *p);
7648 
7649  // Function generating the singleton type initializer
7650  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IEventTimeDecoder*)
7651  {
7652  ::IEventTimeDecoder *ptr = 0;
7653  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IEventTimeDecoder));
7654  static ::ROOT::TGenericClassInfo
7655  instance("IEventTimeDecoder", "GaudiKernel/IEventTimeDecoder.h", 19,
7656  typeid(::IEventTimeDecoder), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7657  &IEventTimeDecoder_Dictionary, isa_proxy, 4,
7658  sizeof(::IEventTimeDecoder) );
7659  instance.SetDelete(&delete_IEventTimeDecoder);
7660  instance.SetDeleteArray(&deleteArray_IEventTimeDecoder);
7661  instance.SetDestructor(&destruct_IEventTimeDecoder);
7662  return &instance;
7663  }
7664  TGenericClassInfo *GenerateInitInstance(const ::IEventTimeDecoder*)
7665  {
7666  return GenerateInitInstanceLocal((::IEventTimeDecoder*)0);
7667  }
7668  // Static variable to force the class initialization
7669  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IEventTimeDecoder*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7670 
7671  // Dictionary for non-ClassDef classes
7672  static TClass *IEventTimeDecoder_Dictionary() {
7673  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IEventTimeDecoder*)0x0)->GetClass();
7674  IEventTimeDecoder_TClassManip(theClass);
7675  return theClass;
7676  }
7677 
7678  static void IEventTimeDecoder_TClassManip(TClass* ){
7679  }
7680 
7681 } // end of namespace ROOT
7682 
7683 namespace ROOT {
7684  static TClass *IHistorySvc_Dictionary();
7685  static void IHistorySvc_TClassManip(TClass*);
7686  static void delete_IHistorySvc(void *p);
7687  static void deleteArray_IHistorySvc(void *p);
7688  static void destruct_IHistorySvc(void *p);
7689 
7690  // Function generating the singleton type initializer
7691  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IHistorySvc*)
7692  {
7693  ::IHistorySvc *ptr = 0;
7694  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IHistorySvc));
7695  static ::ROOT::TGenericClassInfo
7696  instance("IHistorySvc", "GaudiKernel/IHistorySvc.h", 31,
7697  typeid(::IHistorySvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7698  &IHistorySvc_Dictionary, isa_proxy, 4,
7699  sizeof(::IHistorySvc) );
7700  instance.SetDelete(&delete_IHistorySvc);
7701  instance.SetDeleteArray(&deleteArray_IHistorySvc);
7702  instance.SetDestructor(&destruct_IHistorySvc);
7703  return &instance;
7704  }
7705  TGenericClassInfo *GenerateInitInstance(const ::IHistorySvc*)
7706  {
7707  return GenerateInitInstanceLocal((::IHistorySvc*)0);
7708  }
7709  // Static variable to force the class initialization
7710  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IHistorySvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7711 
7712  // Dictionary for non-ClassDef classes
7713  static TClass *IHistorySvc_Dictionary() {
7714  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IHistorySvc*)0x0)->GetClass();
7715  IHistorySvc_TClassManip(theClass);
7716  return theClass;
7717  }
7718 
7719  static void IHistorySvc_TClassManip(TClass* ){
7720  }
7721 
7722 } // end of namespace ROOT
7723 
7724 namespace ROOT {
7725  static TClass *IIncidentListener_Dictionary();
7726  static void IIncidentListener_TClassManip(TClass*);
7727  static void delete_IIncidentListener(void *p);
7728  static void deleteArray_IIncidentListener(void *p);
7729  static void destruct_IIncidentListener(void *p);
7730 
7731  // Function generating the singleton type initializer
7732  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IIncidentListener*)
7733  {
7734  ::IIncidentListener *ptr = 0;
7735  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IIncidentListener));
7736  static ::ROOT::TGenericClassInfo
7737  instance("IIncidentListener", "GaudiKernel/IIncidentListener.h", 15,
7738  typeid(::IIncidentListener), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7739  &IIncidentListener_Dictionary, isa_proxy, 4,
7740  sizeof(::IIncidentListener) );
7741  instance.SetDelete(&delete_IIncidentListener);
7742  instance.SetDeleteArray(&deleteArray_IIncidentListener);
7743  instance.SetDestructor(&destruct_IIncidentListener);
7744  return &instance;
7745  }
7746  TGenericClassInfo *GenerateInitInstance(const ::IIncidentListener*)
7747  {
7748  return GenerateInitInstanceLocal((::IIncidentListener*)0);
7749  }
7750  // Static variable to force the class initialization
7751  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IIncidentListener*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7752 
7753  // Dictionary for non-ClassDef classes
7754  static TClass *IIncidentListener_Dictionary() {
7755  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IIncidentListener*)0x0)->GetClass();
7756  IIncidentListener_TClassManip(theClass);
7757  return theClass;
7758  }
7759 
7760  static void IIncidentListener_TClassManip(TClass* ){
7761  }
7762 
7763 } // end of namespace ROOT
7764 
7765 namespace ROOT {
7766  static TClass *IInspectable_Dictionary();
7767  static void IInspectable_TClassManip(TClass*);
7768  static void delete_IInspectable(void *p);
7769  static void deleteArray_IInspectable(void *p);
7770  static void destruct_IInspectable(void *p);
7771 
7772  // Function generating the singleton type initializer
7773  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IInspectable*)
7774  {
7775  ::IInspectable *ptr = 0;
7776  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IInspectable));
7777  static ::ROOT::TGenericClassInfo
7778  instance("IInspectable", "GaudiKernel/IInspectable.h", 17,
7779  typeid(::IInspectable), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7780  &IInspectable_Dictionary, isa_proxy, 4,
7781  sizeof(::IInspectable) );
7782  instance.SetDelete(&delete_IInspectable);
7783  instance.SetDeleteArray(&deleteArray_IInspectable);
7784  instance.SetDestructor(&destruct_IInspectable);
7785  return &instance;
7786  }
7787  TGenericClassInfo *GenerateInitInstance(const ::IInspectable*)
7788  {
7789  return GenerateInitInstanceLocal((::IInspectable*)0);
7790  }
7791  // Static variable to force the class initialization
7792  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IInspectable*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7793 
7794  // Dictionary for non-ClassDef classes
7795  static TClass *IInspectable_Dictionary() {
7796  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IInspectable*)0x0)->GetClass();
7797  IInspectable_TClassManip(theClass);
7798  return theClass;
7799  }
7800 
7801  static void IInspectable_TClassManip(TClass* ){
7802  }
7803 
7804 } // end of namespace ROOT
7805 
7806 namespace ROOT {
7807  static TClass *IInspector_Dictionary();
7808  static void IInspector_TClassManip(TClass*);
7809  static void delete_IInspector(void *p);
7810  static void deleteArray_IInspector(void *p);
7811  static void destruct_IInspector(void *p);
7812 
7813  // Function generating the singleton type initializer
7814  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IInspector*)
7815  {
7816  ::IInspector *ptr = 0;
7817  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IInspector));
7818  static ::ROOT::TGenericClassInfo
7819  instance("IInspector", "GaudiKernel/IInspector.h", 15,
7820  typeid(::IInspector), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7821  &IInspector_Dictionary, isa_proxy, 4,
7822  sizeof(::IInspector) );
7823  instance.SetDelete(&delete_IInspector);
7824  instance.SetDeleteArray(&deleteArray_IInspector);
7825  instance.SetDestructor(&destruct_IInspector);
7826  return &instance;
7827  }
7828  TGenericClassInfo *GenerateInitInstance(const ::IInspector*)
7829  {
7830  return GenerateInitInstanceLocal((::IInspector*)0);
7831  }
7832  // Static variable to force the class initialization
7833  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IInspector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7834 
7835  // Dictionary for non-ClassDef classes
7836  static TClass *IInspector_Dictionary() {
7837  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IInspector*)0x0)->GetClass();
7838  IInspector_TClassManip(theClass);
7839  return theClass;
7840  }
7841 
7842  static void IInspector_TClassManip(TClass* ){
7843  }
7844 
7845 } // end of namespace ROOT
7846 
7847 namespace ROOT {
7848  static TClass *IJobOptionsSvc_Dictionary();
7849  static void IJobOptionsSvc_TClassManip(TClass*);
7850  static void delete_IJobOptionsSvc(void *p);
7851  static void deleteArray_IJobOptionsSvc(void *p);
7852  static void destruct_IJobOptionsSvc(void *p);
7853 
7854  // Function generating the singleton type initializer
7855  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IJobOptionsSvc*)
7856  {
7857  ::IJobOptionsSvc *ptr = 0;
7858  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IJobOptionsSvc));
7859  static ::ROOT::TGenericClassInfo
7860  instance("IJobOptionsSvc", "GaudiKernel/IJobOptionsSvc.h", 20,
7861  typeid(::IJobOptionsSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7862  &IJobOptionsSvc_Dictionary, isa_proxy, 4,
7863  sizeof(::IJobOptionsSvc) );
7864  instance.SetDelete(&delete_IJobOptionsSvc);
7865  instance.SetDeleteArray(&deleteArray_IJobOptionsSvc);
7866  instance.SetDestructor(&destruct_IJobOptionsSvc);
7867  return &instance;
7868  }
7869  TGenericClassInfo *GenerateInitInstance(const ::IJobOptionsSvc*)
7870  {
7871  return GenerateInitInstanceLocal((::IJobOptionsSvc*)0);
7872  }
7873  // Static variable to force the class initialization
7874  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IJobOptionsSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7875 
7876  // Dictionary for non-ClassDef classes
7877  static TClass *IJobOptionsSvc_Dictionary() {
7878  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IJobOptionsSvc*)0x0)->GetClass();
7879  IJobOptionsSvc_TClassManip(theClass);
7880  return theClass;
7881  }
7882 
7883  static void IJobOptionsSvc_TClassManip(TClass* ){
7884  }
7885 
7886 } // end of namespace ROOT
7887 
7888 namespace ROOT {
7889  static TClass *IMagneticFieldSvc_Dictionary();
7890  static void IMagneticFieldSvc_TClassManip(TClass*);
7891  static void delete_IMagneticFieldSvc(void *p);
7892  static void deleteArray_IMagneticFieldSvc(void *p);
7893  static void destruct_IMagneticFieldSvc(void *p);
7894 
7895  // Function generating the singleton type initializer
7896  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IMagneticFieldSvc*)
7897  {
7898  ::IMagneticFieldSvc *ptr = 0;
7899  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IMagneticFieldSvc));
7900  static ::ROOT::TGenericClassInfo
7901  instance("IMagneticFieldSvc", "GaudiKernel/IMagneticFieldSvc.h", 37,
7902  typeid(::IMagneticFieldSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7903  &IMagneticFieldSvc_Dictionary, isa_proxy, 4,
7904  sizeof(::IMagneticFieldSvc) );
7905  instance.SetDelete(&delete_IMagneticFieldSvc);
7906  instance.SetDeleteArray(&deleteArray_IMagneticFieldSvc);
7907  instance.SetDestructor(&destruct_IMagneticFieldSvc);
7908  return &instance;
7909  }
7910  TGenericClassInfo *GenerateInitInstance(const ::IMagneticFieldSvc*)
7911  {
7912  return GenerateInitInstanceLocal((::IMagneticFieldSvc*)0);
7913  }
7914  // Static variable to force the class initialization
7915  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IMagneticFieldSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7916 
7917  // Dictionary for non-ClassDef classes
7918  static TClass *IMagneticFieldSvc_Dictionary() {
7919  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IMagneticFieldSvc*)0x0)->GetClass();
7920  IMagneticFieldSvc_TClassManip(theClass);
7921  return theClass;
7922  }
7923 
7924  static void IMagneticFieldSvc_TClassManip(TClass* ){
7925  }
7926 
7927 } // end of namespace ROOT
7928 
7929 namespace ROOT {
7930  static TClass *IPartPropSvc_Dictionary();
7931  static void IPartPropSvc_TClassManip(TClass*);
7932  static void delete_IPartPropSvc(void *p);
7933  static void deleteArray_IPartPropSvc(void *p);
7934  static void destruct_IPartPropSvc(void *p);
7935 
7936  // Function generating the singleton type initializer
7937  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IPartPropSvc*)
7938  {
7939  ::IPartPropSvc *ptr = 0;
7940  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IPartPropSvc));
7941  static ::ROOT::TGenericClassInfo
7942  instance("IPartPropSvc", "GaudiKernel/IPartPropSvc.h", 21,
7943  typeid(::IPartPropSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7944  &IPartPropSvc_Dictionary, isa_proxy, 4,
7945  sizeof(::IPartPropSvc) );
7946  instance.SetDelete(&delete_IPartPropSvc);
7947  instance.SetDeleteArray(&deleteArray_IPartPropSvc);
7948  instance.SetDestructor(&destruct_IPartPropSvc);
7949  return &instance;
7950  }
7951  TGenericClassInfo *GenerateInitInstance(const ::IPartPropSvc*)
7952  {
7953  return GenerateInitInstanceLocal((::IPartPropSvc*)0);
7954  }
7955  // Static variable to force the class initialization
7956  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IPartPropSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7957 
7958  // Dictionary for non-ClassDef classes
7959  static TClass *IPartPropSvc_Dictionary() {
7960  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IPartPropSvc*)0x0)->GetClass();
7961  IPartPropSvc_TClassManip(theClass);
7962  return theClass;
7963  }
7964 
7965  static void IPartPropSvc_TClassManip(TClass* ){
7966  }
7967 
7968 } // end of namespace ROOT
7969 
7970 namespace ROOT {
7971  static TClass *IParticlePropertySvc_Dictionary();
7972  static void IParticlePropertySvc_TClassManip(TClass*);
7973  static void delete_IParticlePropertySvc(void *p);
7974  static void deleteArray_IParticlePropertySvc(void *p);
7975  static void destruct_IParticlePropertySvc(void *p);
7976 
7977  // Function generating the singleton type initializer
7978  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IParticlePropertySvc*)
7979  {
7980  ::IParticlePropertySvc *ptr = 0;
7981  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IParticlePropertySvc));
7982  static ::ROOT::TGenericClassInfo
7983  instance("IParticlePropertySvc", "GaudiKernel/IParticlePropertySvc.h", 18,
7984  typeid(::IParticlePropertySvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
7985  &IParticlePropertySvc_Dictionary, isa_proxy, 4,
7986  sizeof(::IParticlePropertySvc) );
7987  instance.SetDelete(&delete_IParticlePropertySvc);
7988  instance.SetDeleteArray(&deleteArray_IParticlePropertySvc);
7989  instance.SetDestructor(&destruct_IParticlePropertySvc);
7990  return &instance;
7991  }
7992  TGenericClassInfo *GenerateInitInstance(const ::IParticlePropertySvc*)
7993  {
7994  return GenerateInitInstanceLocal((::IParticlePropertySvc*)0);
7995  }
7996  // Static variable to force the class initialization
7997  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IParticlePropertySvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
7998 
7999  // Dictionary for non-ClassDef classes
8000  static TClass *IParticlePropertySvc_Dictionary() {
8001  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IParticlePropertySvc*)0x0)->GetClass();
8002  IParticlePropertySvc_TClassManip(theClass);
8003  return theClass;
8004  }
8005 
8006  static void IParticlePropertySvc_TClassManip(TClass* ){
8007  }
8008 
8009 } // end of namespace ROOT
8010 
8011 namespace ROOT {
8012  static TClass *IPartitionControl_Dictionary();
8013  static void IPartitionControl_TClassManip(TClass*);
8014  static void delete_IPartitionControl(void *p);
8015  static void deleteArray_IPartitionControl(void *p);
8016  static void destruct_IPartitionControl(void *p);
8017 
8018  // Function generating the singleton type initializer
8019  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IPartitionControl*)
8020  {
8021  ::IPartitionControl *ptr = 0;
8022  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IPartitionControl));
8023  static ::ROOT::TGenericClassInfo
8024  instance("IPartitionControl", "GaudiKernel/IPartitionControl.h", 66,
8025  typeid(::IPartitionControl), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8026  &IPartitionControl_Dictionary, isa_proxy, 4,
8027  sizeof(::IPartitionControl) );
8028  instance.SetDelete(&delete_IPartitionControl);
8029  instance.SetDeleteArray(&deleteArray_IPartitionControl);
8030  instance.SetDestructor(&destruct_IPartitionControl);
8031  return &instance;
8032  }
8033  TGenericClassInfo *GenerateInitInstance(const ::IPartitionControl*)
8034  {
8035  return GenerateInitInstanceLocal((::IPartitionControl*)0);
8036  }
8037  // Static variable to force the class initialization
8038  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IPartitionControl*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8039 
8040  // Dictionary for non-ClassDef classes
8041  static TClass *IPartitionControl_Dictionary() {
8042  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IPartitionControl*)0x0)->GetClass();
8043  IPartitionControl_TClassManip(theClass);
8044  return theClass;
8045  }
8046 
8047  static void IPartitionControl_TClassManip(TClass* ){
8048  }
8049 
8050 } // end of namespace ROOT
8051 
8052 namespace ROOT {
8053  static TClass *IPersistencySvc_Dictionary();
8054  static void IPersistencySvc_TClassManip(TClass*);
8055  static void delete_IPersistencySvc(void *p);
8056  static void deleteArray_IPersistencySvc(void *p);
8057  static void destruct_IPersistencySvc(void *p);
8058 
8059  // Function generating the singleton type initializer
8060  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IPersistencySvc*)
8061  {
8062  ::IPersistencySvc *ptr = 0;
8063  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IPersistencySvc));
8064  static ::ROOT::TGenericClassInfo
8065  instance("IPersistencySvc", "GaudiKernel/IPersistencySvc.h", 19,
8066  typeid(::IPersistencySvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8067  &IPersistencySvc_Dictionary, isa_proxy, 4,
8068  sizeof(::IPersistencySvc) );
8069  instance.SetDelete(&delete_IPersistencySvc);
8070  instance.SetDeleteArray(&deleteArray_IPersistencySvc);
8071  instance.SetDestructor(&destruct_IPersistencySvc);
8072  return &instance;
8073  }
8074  TGenericClassInfo *GenerateInitInstance(const ::IPersistencySvc*)
8075  {
8076  return GenerateInitInstanceLocal((::IPersistencySvc*)0);
8077  }
8078  // Static variable to force the class initialization
8079  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IPersistencySvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8080 
8081  // Dictionary for non-ClassDef classes
8082  static TClass *IPersistencySvc_Dictionary() {
8083  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IPersistencySvc*)0x0)->GetClass();
8084  IPersistencySvc_TClassManip(theClass);
8085  return theClass;
8086  }
8087 
8088  static void IPersistencySvc_TClassManip(TClass* ){
8089  }
8090 
8091 } // end of namespace ROOT
8092 
8093 namespace ROOT {
8094  static TClass *IRndmEngine_Dictionary();
8095  static void IRndmEngine_TClassManip(TClass*);
8096  static void delete_IRndmEngine(void *p);
8097  static void deleteArray_IRndmEngine(void *p);
8098  static void destruct_IRndmEngine(void *p);
8099 
8100  // Function generating the singleton type initializer
8101  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IRndmEngine*)
8102  {
8103  ::IRndmEngine *ptr = 0;
8104  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IRndmEngine));
8105  static ::ROOT::TGenericClassInfo
8106  instance("IRndmEngine", "GaudiKernel/IRndmEngine.h", 19,
8107  typeid(::IRndmEngine), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8108  &IRndmEngine_Dictionary, isa_proxy, 4,
8109  sizeof(::IRndmEngine) );
8110  instance.SetDelete(&delete_IRndmEngine);
8111  instance.SetDeleteArray(&deleteArray_IRndmEngine);
8112  instance.SetDestructor(&destruct_IRndmEngine);
8113  return &instance;
8114  }
8115  TGenericClassInfo *GenerateInitInstance(const ::IRndmEngine*)
8116  {
8117  return GenerateInitInstanceLocal((::IRndmEngine*)0);
8118  }
8119  // Static variable to force the class initialization
8120  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IRndmEngine*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8121 
8122  // Dictionary for non-ClassDef classes
8123  static TClass *IRndmEngine_Dictionary() {
8124  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IRndmEngine*)0x0)->GetClass();
8125  IRndmEngine_TClassManip(theClass);
8126  return theClass;
8127  }
8128 
8129  static void IRndmEngine_TClassManip(TClass* ){
8130  }
8131 
8132 } // end of namespace ROOT
8133 
8134 namespace ROOT {
8135  static TClass *IRunable_Dictionary();
8136  static void IRunable_TClassManip(TClass*);
8137  static void delete_IRunable(void *p);
8138  static void deleteArray_IRunable(void *p);
8139  static void destruct_IRunable(void *p);
8140 
8141  // Function generating the singleton type initializer
8142  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IRunable*)
8143  {
8144  ::IRunable *ptr = 0;
8145  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IRunable));
8146  static ::ROOT::TGenericClassInfo
8147  instance("IRunable", "GaudiKernel/IRunable.h", 18,
8148  typeid(::IRunable), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8149  &IRunable_Dictionary, isa_proxy, 4,
8150  sizeof(::IRunable) );
8151  instance.SetDelete(&delete_IRunable);
8152  instance.SetDeleteArray(&deleteArray_IRunable);
8153  instance.SetDestructor(&destruct_IRunable);
8154  return &instance;
8155  }
8156  TGenericClassInfo *GenerateInitInstance(const ::IRunable*)
8157  {
8158  return GenerateInitInstanceLocal((::IRunable*)0);
8159  }
8160  // Static variable to force the class initialization
8161  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IRunable*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8162 
8163  // Dictionary for non-ClassDef classes
8164  static TClass *IRunable_Dictionary() {
8165  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IRunable*)0x0)->GetClass();
8166  IRunable_TClassManip(theClass);
8167  return theClass;
8168  }
8169 
8170  static void IRunable_TClassManip(TClass* ){
8171  }
8172 
8173 } // end of namespace ROOT
8174 
8175 namespace ROOT {
8176  static TClass *ISelectStatement_Dictionary();
8177  static void ISelectStatement_TClassManip(TClass*);
8178  static void delete_ISelectStatement(void *p);
8179  static void deleteArray_ISelectStatement(void *p);
8180  static void destruct_ISelectStatement(void *p);
8181 
8182  // Function generating the singleton type initializer
8183  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ISelectStatement*)
8184  {
8185  ::ISelectStatement *ptr = 0;
8186  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ISelectStatement));
8187  static ::ROOT::TGenericClassInfo
8188  instance("ISelectStatement", "GaudiKernel/ISelectStatement.h", 32,
8189  typeid(::ISelectStatement), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8190  &ISelectStatement_Dictionary, isa_proxy, 4,
8191  sizeof(::ISelectStatement) );
8192  instance.SetDelete(&delete_ISelectStatement);
8193  instance.SetDeleteArray(&deleteArray_ISelectStatement);
8194  instance.SetDestructor(&destruct_ISelectStatement);
8195  return &instance;
8196  }
8197  TGenericClassInfo *GenerateInitInstance(const ::ISelectStatement*)
8198  {
8199  return GenerateInitInstanceLocal((::ISelectStatement*)0);
8200  }
8201  // Static variable to force the class initialization
8202  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ISelectStatement*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8203 
8204  // Dictionary for non-ClassDef classes
8205  static TClass *ISelectStatement_Dictionary() {
8206  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ISelectStatement*)0x0)->GetClass();
8207  ISelectStatement_TClassManip(theClass);
8208  return theClass;
8209  }
8210 
8211  static void ISelectStatement_TClassManip(TClass* ){
8212  }
8213 
8214 } // end of namespace ROOT
8215 
8216 namespace ROOT {
8217  static TClass *ISerialize_Dictionary();
8218  static void ISerialize_TClassManip(TClass*);
8219  static void delete_ISerialize(void *p);
8220  static void deleteArray_ISerialize(void *p);
8221  static void destruct_ISerialize(void *p);
8222 
8223  // Function generating the singleton type initializer
8224  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ISerialize*)
8225  {
8226  ::ISerialize *ptr = 0;
8227  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ISerialize));
8228  static ::ROOT::TGenericClassInfo
8229  instance("ISerialize", "GaudiKernel/ISerialize.h", 17,
8230  typeid(::ISerialize), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8231  &ISerialize_Dictionary, isa_proxy, 4,
8232  sizeof(::ISerialize) );
8233  instance.SetDelete(&delete_ISerialize);
8234  instance.SetDeleteArray(&deleteArray_ISerialize);
8235  instance.SetDestructor(&destruct_ISerialize);
8236  return &instance;
8237  }
8238  TGenericClassInfo *GenerateInitInstance(const ::ISerialize*)
8239  {
8240  return GenerateInitInstanceLocal((::ISerialize*)0);
8241  }
8242  // Static variable to force the class initialization
8243  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ISerialize*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8244 
8245  // Dictionary for non-ClassDef classes
8246  static TClass *ISerialize_Dictionary() {
8247  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ISerialize*)0x0)->GetClass();
8248  ISerialize_TClassManip(theClass);
8249  return theClass;
8250  }
8251 
8252  static void ISerialize_TClassManip(TClass* ){
8253  }
8254 
8255 } // end of namespace ROOT
8256 
8257 namespace ROOT {
8258  static TClass *IStagerSvc_Dictionary();
8259  static void IStagerSvc_TClassManip(TClass*);
8260  static void delete_IStagerSvc(void *p);
8261  static void deleteArray_IStagerSvc(void *p);
8262  static void destruct_IStagerSvc(void *p);
8263 
8264  // Function generating the singleton type initializer
8265  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IStagerSvc*)
8266  {
8267  ::IStagerSvc *ptr = 0;
8268  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IStagerSvc));
8269  static ::ROOT::TGenericClassInfo
8270  instance("IStagerSvc", "GaudiKernel/IStagerSvc.h", 11,
8271  typeid(::IStagerSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8272  &IStagerSvc_Dictionary, isa_proxy, 4,
8273  sizeof(::IStagerSvc) );
8274  instance.SetDelete(&delete_IStagerSvc);
8275  instance.SetDeleteArray(&deleteArray_IStagerSvc);
8276  instance.SetDestructor(&destruct_IStagerSvc);
8277  return &instance;
8278  }
8279  TGenericClassInfo *GenerateInitInstance(const ::IStagerSvc*)
8280  {
8281  return GenerateInitInstanceLocal((::IStagerSvc*)0);
8282  }
8283  // Static variable to force the class initialization
8284  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IStagerSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8285 
8286  // Dictionary for non-ClassDef classes
8287  static TClass *IStagerSvc_Dictionary() {
8288  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IStagerSvc*)0x0)->GetClass();
8289  IStagerSvc_TClassManip(theClass);
8290  return theClass;
8291  }
8292 
8293  static void IStagerSvc_TClassManip(TClass* ){
8294  }
8295 
8296 } // end of namespace ROOT
8297 
8298 namespace ROOT {
8299  static TClass *IStatusCodeSvc_Dictionary();
8300  static void IStatusCodeSvc_TClassManip(TClass*);
8301  static void delete_IStatusCodeSvc(void *p);
8302  static void deleteArray_IStatusCodeSvc(void *p);
8303  static void destruct_IStatusCodeSvc(void *p);
8304 
8305  // Function generating the singleton type initializer
8306  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IStatusCodeSvc*)
8307  {
8308  ::IStatusCodeSvc *ptr = 0;
8309  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IStatusCodeSvc));
8310  static ::ROOT::TGenericClassInfo
8311  instance("IStatusCodeSvc", "GaudiKernel/IStatusCodeSvc.h", 7,
8312  typeid(::IStatusCodeSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8313  &IStatusCodeSvc_Dictionary, isa_proxy, 4,
8314  sizeof(::IStatusCodeSvc) );
8315  instance.SetDelete(&delete_IStatusCodeSvc);
8316  instance.SetDeleteArray(&deleteArray_IStatusCodeSvc);
8317  instance.SetDestructor(&destruct_IStatusCodeSvc);
8318  return &instance;
8319  }
8320  TGenericClassInfo *GenerateInitInstance(const ::IStatusCodeSvc*)
8321  {
8322  return GenerateInitInstanceLocal((::IStatusCodeSvc*)0);
8323  }
8324  // Static variable to force the class initialization
8325  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IStatusCodeSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8326 
8327  // Dictionary for non-ClassDef classes
8328  static TClass *IStatusCodeSvc_Dictionary() {
8329  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IStatusCodeSvc*)0x0)->GetClass();
8330  IStatusCodeSvc_TClassManip(theClass);
8331  return theClass;
8332  }
8333 
8334  static void IStatusCodeSvc_TClassManip(TClass* ){
8335  }
8336 
8337 } // end of namespace ROOT
8338 
8339 namespace ROOT {
8340  static TClass *ITHistSvc_Dictionary();
8341  static void ITHistSvc_TClassManip(TClass*);
8342  static void delete_ITHistSvc(void *p);
8343  static void deleteArray_ITHistSvc(void *p);
8344  static void destruct_ITHistSvc(void *p);
8345 
8346  // Function generating the singleton type initializer
8347  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ITHistSvc*)
8348  {
8349  ::ITHistSvc *ptr = 0;
8350  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ITHistSvc));
8351  static ::ROOT::TGenericClassInfo
8352  instance("ITHistSvc", "GaudiKernel/ITHistSvc.h", 23,
8353  typeid(::ITHistSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8354  &ITHistSvc_Dictionary, isa_proxy, 4,
8355  sizeof(::ITHistSvc) );
8356  instance.SetDelete(&delete_ITHistSvc);
8357  instance.SetDeleteArray(&deleteArray_ITHistSvc);
8358  instance.SetDestructor(&destruct_ITHistSvc);
8359  return &instance;
8360  }
8361  TGenericClassInfo *GenerateInitInstance(const ::ITHistSvc*)
8362  {
8363  return GenerateInitInstanceLocal((::ITHistSvc*)0);
8364  }
8365  // Static variable to force the class initialization
8366  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ITHistSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8367 
8368  // Dictionary for non-ClassDef classes
8369  static TClass *ITHistSvc_Dictionary() {
8370  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ITHistSvc*)0x0)->GetClass();
8371  ITHistSvc_TClassManip(theClass);
8372  return theClass;
8373  }
8374 
8375  static void ITHistSvc_TClassManip(TClass* ){
8376  }
8377 
8378 } // end of namespace ROOT
8379 
8380 namespace ROOT {
8381  static TClass *IUpdateManagerSvc_Dictionary();
8382  static void IUpdateManagerSvc_TClassManip(TClass*);
8383  static void delete_IUpdateManagerSvc(void *p);
8384  static void deleteArray_IUpdateManagerSvc(void *p);
8385  static void destruct_IUpdateManagerSvc(void *p);
8386 
8387  // Function generating the singleton type initializer
8388  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IUpdateManagerSvc*)
8389  {
8390  ::IUpdateManagerSvc *ptr = 0;
8391  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IUpdateManagerSvc));
8392  static ::ROOT::TGenericClassInfo
8393  instance("IUpdateManagerSvc", "GaudiKernel/IUpdateManagerSvc.h", 141,
8394  typeid(::IUpdateManagerSvc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8395  &IUpdateManagerSvc_Dictionary, isa_proxy, 4,
8396  sizeof(::IUpdateManagerSvc) );
8397  instance.SetDelete(&delete_IUpdateManagerSvc);
8398  instance.SetDeleteArray(&deleteArray_IUpdateManagerSvc);
8399  instance.SetDestructor(&destruct_IUpdateManagerSvc);
8400  return &instance;
8401  }
8402  TGenericClassInfo *GenerateInitInstance(const ::IUpdateManagerSvc*)
8403  {
8404  return GenerateInitInstanceLocal((::IUpdateManagerSvc*)0);
8405  }
8406  // Static variable to force the class initialization
8407  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IUpdateManagerSvc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8408 
8409  // Dictionary for non-ClassDef classes
8410  static TClass *IUpdateManagerSvc_Dictionary() {
8411  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IUpdateManagerSvc*)0x0)->GetClass();
8412  IUpdateManagerSvc_TClassManip(theClass);
8413  return theClass;
8414  }
8415 
8416  static void IUpdateManagerSvc_TClassManip(TClass* ){
8417  }
8418 
8419 } // end of namespace ROOT
8420 
8421 namespace ROOT {
8422  static TClass *IUpdateable_Dictionary();
8423  static void IUpdateable_TClassManip(TClass*);
8424  static void delete_IUpdateable(void *p);
8425  static void deleteArray_IUpdateable(void *p);
8426  static void destruct_IUpdateable(void *p);
8427 
8428  // Function generating the singleton type initializer
8429  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IUpdateable*)
8430  {
8431  ::IUpdateable *ptr = 0;
8432  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IUpdateable));
8433  static ::ROOT::TGenericClassInfo
8434  instance("IUpdateable", "GaudiKernel/IUpdateable.h", 15,
8435  typeid(::IUpdateable), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8436  &IUpdateable_Dictionary, isa_proxy, 4,
8437  sizeof(::IUpdateable) );
8438  instance.SetDelete(&delete_IUpdateable);
8439  instance.SetDeleteArray(&deleteArray_IUpdateable);
8440  instance.SetDestructor(&destruct_IUpdateable);
8441  return &instance;
8442  }
8443  TGenericClassInfo *GenerateInitInstance(const ::IUpdateable*)
8444  {
8445  return GenerateInitInstanceLocal((::IUpdateable*)0);
8446  }
8447  // Static variable to force the class initialization
8448  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IUpdateable*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8449 
8450  // Dictionary for non-ClassDef classes
8451  static TClass *IUpdateable_Dictionary() {
8452  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IUpdateable*)0x0)->GetClass();
8453  IUpdateable_TClassManip(theClass);
8454  return theClass;
8455  }
8456 
8457  static void IUpdateable_TClassManip(TClass* ){
8458  }
8459 
8460 } // end of namespace ROOT
8461 
8462 namespace ROOT {
8463  static TClass *IValidity_Dictionary();
8464  static void IValidity_TClassManip(TClass*);
8465  static void delete_IValidity(void *p);
8466  static void deleteArray_IValidity(void *p);
8467  static void destruct_IValidity(void *p);
8468 
8469  // Function generating the singleton type initializer
8470  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IValidity*)
8471  {
8472  ::IValidity *ptr = 0;
8473  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IValidity));
8474  static ::ROOT::TGenericClassInfo
8475  instance("IValidity", "GaudiKernel/IValidity.h", 12,
8476  typeid(::IValidity), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8477  &IValidity_Dictionary, isa_proxy, 4,
8478  sizeof(::IValidity) );
8479  instance.SetDelete(&delete_IValidity);
8480  instance.SetDeleteArray(&deleteArray_IValidity);
8481  instance.SetDestructor(&destruct_IValidity);
8482  return &instance;
8483  }
8484  TGenericClassInfo *GenerateInitInstance(const ::IValidity*)
8485  {
8486  return GenerateInitInstanceLocal((::IValidity*)0);
8487  }
8488  // Static variable to force the class initialization
8489  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IValidity*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8490 
8491  // Dictionary for non-ClassDef classes
8492  static TClass *IValidity_Dictionary() {
8493  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IValidity*)0x0)->GetClass();
8494  IValidity_TClassManip(theClass);
8495  return theClass;
8496  }
8497 
8498  static void IValidity_TClassManip(TClass* ){
8499  }
8500 
8501 } // end of namespace ROOT
8502 
8503 namespace ROOT {
8504  static TClass *IUpdateManagerSvccLcLPythonHelper_Dictionary();
8505  static void IUpdateManagerSvccLcLPythonHelper_TClassManip(TClass*);
8506  static void *new_IUpdateManagerSvccLcLPythonHelper(void *p = 0);
8507  static void *newArray_IUpdateManagerSvccLcLPythonHelper(Long_t size, void *p);
8508  static void delete_IUpdateManagerSvccLcLPythonHelper(void *p);
8509  static void deleteArray_IUpdateManagerSvccLcLPythonHelper(void *p);
8510  static void destruct_IUpdateManagerSvccLcLPythonHelper(void *p);
8511 
8512  // Function generating the singleton type initializer
8513  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IUpdateManagerSvc::PythonHelper*)
8514  {
8515  ::IUpdateManagerSvc::PythonHelper *ptr = 0;
8516  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IUpdateManagerSvc::PythonHelper));
8517  static ::ROOT::TGenericClassInfo
8518  instance("IUpdateManagerSvc::PythonHelper", "", 206,
8519  typeid(::IUpdateManagerSvc::PythonHelper), ::ROOT::Internal::DefineBehavior(ptr, ptr),
8520  &IUpdateManagerSvccLcLPythonHelper_Dictionary, isa_proxy, 4,
8521  sizeof(::IUpdateManagerSvc::PythonHelper) );
8522  instance.SetNew(&new_IUpdateManagerSvccLcLPythonHelper);
8523  instance.SetNewArray(&newArray_IUpdateManagerSvccLcLPythonHelper);
8524  instance.SetDelete(&delete_IUpdateManagerSvccLcLPythonHelper);
8525  instance.SetDeleteArray(&deleteArray_IUpdateManagerSvccLcLPythonHelper);
8526  instance.SetDestructor(&destruct_IUpdateManagerSvccLcLPythonHelper);
8527  return &instance;
8528  }
8529  TGenericClassInfo *GenerateInitInstance(const ::IUpdateManagerSvc::PythonHelper*)
8530  {
8531  return GenerateInitInstanceLocal((::IUpdateManagerSvc::PythonHelper*)0);
8532  }
8533  // Static variable to force the class initialization
8534  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IUpdateManagerSvc::PythonHelper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
8535 
8536  // Dictionary for non-ClassDef classes
8537  static TClass *IUpdateManagerSvccLcLPythonHelper_Dictionary() {
8538  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IUpdateManagerSvc::PythonHelper*)0x0)->GetClass();
8539  IUpdateManagerSvccLcLPythonHelper_TClassManip(theClass);
8540  return theClass;
8541  }
8542 
8543  static void IUpdateManagerSvccLcLPythonHelper_TClassManip(TClass* ){
8544  }
8545 
8546 } // end of namespace ROOT
8547 
8548 namespace ROOT {
8549  // Wrappers around operator new
8550  static void *new_StatusCode(void *p) {
8551  return p ? new(p) ::StatusCode : new ::StatusCode;
8552  }
8553  static void *newArray_StatusCode(Long_t nElements, void *p) {
8554  return p ? new(p) ::StatusCode[nElements] : new ::StatusCode[nElements];
8555  }
8556  // Wrapper around operator delete
8557  static void delete_StatusCode(void *p) {
8558  delete ((::StatusCode*)p);
8559  }
8560  static void deleteArray_StatusCode(void *p) {
8561  delete [] ((::StatusCode*)p);
8562  }
8563  static void destruct_StatusCode(void *p) {
8564  typedef ::StatusCode current_t;
8565  ((current_t*)p)->~current_t();
8566  }
8567 } // end of namespace ROOT for class ::StatusCode
8568 
8569 namespace ROOT {
8570  // Wrapper around operator delete
8571  static void delete_InterfaceID(void *p) {
8572  delete ((::InterfaceID*)p);
8573  }
8574  static void deleteArray_InterfaceID(void *p) {
8575  delete [] ((::InterfaceID*)p);
8576  }
8577  static void destruct_InterfaceID(void *p) {
8578  typedef ::InterfaceID current_t;
8579  ((current_t*)p)->~current_t();
8580  }
8581 } // end of namespace ROOT for class ::InterfaceID
8582 
8583 namespace ROOT {
8584  // Wrapper around operator delete
8585  static void delete_IInterface(void *p) {
8586  delete ((::IInterface*)p);
8587  }
8588  static void deleteArray_IInterface(void *p) {
8589  delete [] ((::IInterface*)p);
8590  }
8591  static void destruct_IInterface(void *p) {
8592  typedef ::IInterface current_t;
8593  ((current_t*)p)->~current_t();
8594  }
8595 } // end of namespace ROOT for class ::IInterface
8596 
8597 namespace ROOT {
8598  // Wrapper around operator delete
8599  static void delete_IMessageSvc(void *p) {
8600  delete ((::IMessageSvc*)p);
8601  }
8602  static void deleteArray_IMessageSvc(void *p) {
8603  delete [] ((::IMessageSvc*)p);
8604  }
8605  static void destruct_IMessageSvc(void *p) {
8606  typedef ::IMessageSvc current_t;
8607  ((current_t*)p)->~current_t();
8608  }
8609 } // end of namespace ROOT for class ::IMessageSvc
8610 
8611 namespace ROOT {
8612  // Wrapper around operator delete
8613  static void delete_INamedInterface(void *p) {
8614  delete ((::INamedInterface*)p);
8615  }
8616  static void deleteArray_INamedInterface(void *p) {
8617  delete [] ((::INamedInterface*)p);
8618  }
8619  static void destruct_INamedInterface(void *p) {
8620  typedef ::INamedInterface current_t;
8621  ((current_t*)p)->~current_t();
8622  }
8623 } // end of namespace ROOT for class ::INamedInterface
8624 
8625 namespace ROOT {
8626  // Wrapper around operator delete
8627  static void delete_IStateful(void *p) {
8628  delete ((::IStateful*)p);
8629  }
8630  static void deleteArray_IStateful(void *p) {
8631  delete [] ((::IStateful*)p);
8632  }
8633  static void destruct_IStateful(void *p) {
8634  typedef ::IStateful current_t;
8635  ((current_t*)p)->~current_t();
8636  }
8637 } // end of namespace ROOT for class ::IStateful
8638 
8639 namespace ROOT {
8640  // Wrapper around operator delete
8641  static void delete_IService(void *p) {
8642  delete ((::IService*)p);
8643  }
8644  static void deleteArray_IService(void *p) {
8645  delete [] ((::IService*)p);
8646  }
8647  static void destruct_IService(void *p) {
8648  typedef ::IService current_t;
8649  ((current_t*)p)->~current_t();
8650  }
8651 } // end of namespace ROOT for class ::IService
8652 
8653 namespace ROOT {
8654  // Wrappers around operator new
8655  static void *new_SmartIFlEIServicegR(void *p) {
8656  return p ? new(p) ::SmartIF<IService> : new ::SmartIF<IService>;
8657  }
8658  static void *newArray_SmartIFlEIServicegR(Long_t nElements, void *p) {
8659  return p ? new(p) ::SmartIF<IService>[nElements] : new ::SmartIF<IService>[nElements];
8660  }
8661  // Wrapper around operator delete
8662  static void delete_SmartIFlEIServicegR(void *p) {
8663  delete ((::SmartIF<IService>*)p);
8664  }
8665  static void deleteArray_SmartIFlEIServicegR(void *p) {
8666  delete [] ((::SmartIF<IService>*)p);
8667  }
8668  static void destruct_SmartIFlEIServicegR(void *p) {
8669  typedef ::SmartIF<IService> current_t;
8670  ((current_t*)p)->~current_t();
8671  }
8672 } // end of namespace ROOT for class ::SmartIF<IService>
8673 
8674 namespace ROOT {
8675  // Wrappers around operator new
8676  static void *new_SmartIFlEISvcLocatorgR(void *p) {
8677  return p ? new(p) ::SmartIF<ISvcLocator> : new ::SmartIF<ISvcLocator>;
8678  }
8679  static void *newArray_SmartIFlEISvcLocatorgR(Long_t nElements, void *p) {
8680  return p ? new(p) ::SmartIF<ISvcLocator>[nElements] : new ::SmartIF<ISvcLocator>[nElements];
8681  }
8682  // Wrapper around operator delete
8683  static void delete_SmartIFlEISvcLocatorgR(void *p) {
8684  delete ((::SmartIF<ISvcLocator>*)p);
8685  }
8686  static void deleteArray_SmartIFlEISvcLocatorgR(void *p) {
8687  delete [] ((::SmartIF<ISvcLocator>*)p);
8688  }
8689  static void destruct_SmartIFlEISvcLocatorgR(void *p) {
8690  typedef ::SmartIF<ISvcLocator> current_t;
8691  ((current_t*)p)->~current_t();
8692  }
8693 } // end of namespace ROOT for class ::SmartIF<ISvcLocator>
8694 
8695 namespace ROOT {
8696  // Wrappers around operator new
8697  static void *new_SmartIFlEIMessageSvcgR(void *p) {
8698  return p ? new(p) ::SmartIF<IMessageSvc> : new ::SmartIF<IMessageSvc>;
8699  }
8700  static void *newArray_SmartIFlEIMessageSvcgR(Long_t nElements, void *p) {
8701  return p ? new(p) ::SmartIF<IMessageSvc>[nElements] : new ::SmartIF<IMessageSvc>[nElements];
8702  }
8703  // Wrapper around operator delete
8704  static void delete_SmartIFlEIMessageSvcgR(void *p) {
8705  delete ((::SmartIF<IMessageSvc>*)p);
8706  }
8707  static void deleteArray_SmartIFlEIMessageSvcgR(void *p) {
8708  delete [] ((::SmartIF<IMessageSvc>*)p);
8709  }
8710  static void destruct_SmartIFlEIMessageSvcgR(void *p) {
8711  typedef ::SmartIF<IMessageSvc> current_t;
8712  ((current_t*)p)->~current_t();
8713  }
8714 } // end of namespace ROOT for class ::SmartIF<IMessageSvc>
8715 
8716 namespace ROOT {
8717  // Wrappers around operator new
8718  static void *new_SmartIFlEIPropertygR(void *p) {
8719  return p ? new(p) ::SmartIF<IProperty> : new ::SmartIF<IProperty>;
8720  }
8721  static void *newArray_SmartIFlEIPropertygR(Long_t nElements, void *p) {
8722  return p ? new(p) ::SmartIF<IProperty>[nElements] : new ::SmartIF<IProperty>[nElements];
8723  }
8724  // Wrapper around operator delete
8725  static void delete_SmartIFlEIPropertygR(void *p) {
8726  delete ((::SmartIF<IProperty>*)p);
8727  }
8728  static void deleteArray_SmartIFlEIPropertygR(void *p) {
8729  delete [] ((::SmartIF<IProperty>*)p);
8730  }
8731  static void destruct_SmartIFlEIPropertygR(void *p) {
8732  typedef ::SmartIF<IProperty> current_t;
8733  ((current_t*)p)->~current_t();
8734  }
8735 } // end of namespace ROOT for class ::SmartIF<IProperty>
8736 
8737 namespace ROOT {
8738  // Wrappers around operator new
8739  static void *new_SmartIFlEIDataProviderSvcgR(void *p) {
8740  return p ? new(p) ::SmartIF<IDataProviderSvc> : new ::SmartIF<IDataProviderSvc>;
8741  }
8742  static void *newArray_SmartIFlEIDataProviderSvcgR(Long_t nElements, void *p) {
8743  return p ? new(p) ::SmartIF<IDataProviderSvc>[nElements] : new ::SmartIF<IDataProviderSvc>[nElements];
8744  }
8745  // Wrapper around operator delete
8746  static void delete_SmartIFlEIDataProviderSvcgR(void *p) {
8747  delete ((::SmartIF<IDataProviderSvc>*)p);
8748  }
8749  static void deleteArray_SmartIFlEIDataProviderSvcgR(void *p) {
8750  delete [] ((::SmartIF<IDataProviderSvc>*)p);
8751  }
8752  static void destruct_SmartIFlEIDataProviderSvcgR(void *p) {
8753  typedef ::SmartIF<IDataProviderSvc> current_t;
8754  ((current_t*)p)->~current_t();
8755  }
8756 } // end of namespace ROOT for class ::SmartIF<IDataProviderSvc>
8757 
8758 namespace ROOT {
8759  // Wrappers around operator new
8760  static void *new_SmartIFlEIToolSvcgR(void *p) {
8761  return p ? new(p) ::SmartIF<IToolSvc> : new ::SmartIF<IToolSvc>;
8762  }
8763  static void *newArray_SmartIFlEIToolSvcgR(Long_t nElements, void *p) {
8764  return p ? new(p) ::SmartIF<IToolSvc>[nElements] : new ::SmartIF<IToolSvc>[nElements];
8765  }
8766  // Wrapper around operator delete
8767  static void delete_SmartIFlEIToolSvcgR(void *p) {
8768  delete ((::SmartIF<IToolSvc>*)p);
8769  }
8770  static void deleteArray_SmartIFlEIToolSvcgR(void *p) {
8771  delete [] ((::SmartIF<IToolSvc>*)p);
8772  }
8773  static void destruct_SmartIFlEIToolSvcgR(void *p) {
8774  typedef ::SmartIF<IToolSvc> current_t;
8775  ((current_t*)p)->~current_t();
8776  }
8777 } // end of namespace ROOT for class ::SmartIF<IToolSvc>
8778 
8779 namespace ROOT {
8780  // Wrappers around operator new
8781  static void *new_SmartIFlEIMonitorSvcgR(void *p) {
8782  return p ? new(p) ::SmartIF<IMonitorSvc> : new ::SmartIF<IMonitorSvc>;
8783  }
8784  static void *newArray_SmartIFlEIMonitorSvcgR(Long_t nElements, void *p) {
8785  return p ? new(p) ::SmartIF<IMonitorSvc>[nElements] : new ::SmartIF<IMonitorSvc>[nElements];
8786  }
8787  // Wrapper around operator delete
8788  static void delete_SmartIFlEIMonitorSvcgR(void *p) {
8789  delete ((::SmartIF<IMonitorSvc>*)p);
8790  }
8791  static void deleteArray_SmartIFlEIMonitorSvcgR(void *p) {
8792  delete [] ((::SmartIF<IMonitorSvc>*)p);
8793  }
8794  static void destruct_SmartIFlEIMonitorSvcgR(void *p) {
8795  typedef ::SmartIF<IMonitorSvc> current_t;
8796  ((current_t*)p)->~current_t();
8797  }
8798 } // end of namespace ROOT for class ::SmartIF<IMonitorSvc>
8799 
8800 namespace ROOT {
8801  // Wrappers around operator new
8802  static void *new_SmartIFlEIAuditorSvcgR(void *p) {
8803  return p ? new(p) ::SmartIF<IAuditorSvc> : new ::SmartIF<IAuditorSvc>;
8804  }
8805  static void *newArray_SmartIFlEIAuditorSvcgR(Long_t nElements, void *p) {
8806  return p ? new(p) ::SmartIF<IAuditorSvc>[nElements] : new ::SmartIF<IAuditorSvc>[nElements];
8807  }
8808  // Wrapper around operator delete
8809  static void delete_SmartIFlEIAuditorSvcgR(void *p) {
8810  delete ((::SmartIF<IAuditorSvc>*)p);
8811  }
8812  static void deleteArray_SmartIFlEIAuditorSvcgR(void *p) {
8813  delete [] ((::SmartIF<IAuditorSvc>*)p);
8814  }
8815  static void destruct_SmartIFlEIAuditorSvcgR(void *p) {
8816  typedef ::SmartIF<IAuditorSvc> current_t;
8817  ((current_t*)p)->~current_t();
8818  }
8819 } // end of namespace ROOT for class ::SmartIF<IAuditorSvc>
8820 
8821 namespace ROOT {
8822  // Wrappers around operator new
8823  static void *new_SmartIFlEIAlgContextSvcgR(void *p) {
8824  return p ? new(p) ::SmartIF<IAlgContextSvc> : new ::SmartIF<IAlgContextSvc>;
8825  }
8826  static void *newArray_SmartIFlEIAlgContextSvcgR(Long_t nElements, void *p) {
8827  return p ? new(p) ::SmartIF<IAlgContextSvc>[nElements] : new ::SmartIF<IAlgContextSvc>[nElements];
8828  }
8829  // Wrapper around operator delete
8830  static void delete_SmartIFlEIAlgContextSvcgR(void *p) {
8831  delete ((::SmartIF<IAlgContextSvc>*)p);
8832  }
8833  static void deleteArray_SmartIFlEIAlgContextSvcgR(void *p) {
8834  delete [] ((::SmartIF<IAlgContextSvc>*)p);
8835  }
8836  static void destruct_SmartIFlEIAlgContextSvcgR(void *p) {
8837  typedef ::SmartIF<IAlgContextSvc> current_t;
8838  ((current_t*)p)->~current_t();
8839  }
8840 } // end of namespace ROOT for class ::SmartIF<IAlgContextSvc>
8841 
8842 namespace ROOT {
8843  // Wrappers around operator new
8844  static void *new_SmartIFlEIAlgorithmgR(void *p) {
8845  return p ? new(p) ::SmartIF<IAlgorithm> : new ::SmartIF<IAlgorithm>;
8846  }
8847  static void *newArray_SmartIFlEIAlgorithmgR(Long_t nElements, void *p) {
8848  return p ? new(p) ::SmartIF<IAlgorithm>[nElements] : new ::SmartIF<IAlgorithm>[nElements];
8849  }
8850  // Wrapper around operator delete
8851  static void delete_SmartIFlEIAlgorithmgR(void *p) {
8852  delete ((::SmartIF<IAlgorithm>*)p);
8853  }
8854  static void deleteArray_SmartIFlEIAlgorithmgR(void *p) {
8855  delete [] ((::SmartIF<IAlgorithm>*)p);
8856  }
8857  static void destruct_SmartIFlEIAlgorithmgR(void *p) {
8858  typedef ::SmartIF<IAlgorithm> current_t;
8859  ((current_t*)p)->~current_t();
8860  }
8861 } // end of namespace ROOT for class ::SmartIF<IAlgorithm>
8862 
8863 namespace ROOT {
8864  // Wrappers around operator new
8865  static void *new_SmartIFlEIConversionSvcgR(void *p) {
8866  return p ? new(p) ::SmartIF<IConversionSvc> : new ::SmartIF<IConversionSvc>;
8867  }
8868  static void *newArray_SmartIFlEIConversionSvcgR(Long_t nElements, void *p) {
8869  return p ? new(p) ::SmartIF<IConversionSvc>[nElements] : new ::SmartIF<IConversionSvc>[nElements];
8870  }
8871  // Wrapper around operator delete
8872  static void delete_SmartIFlEIConversionSvcgR(void *p) {
8873  delete ((::SmartIF<IConversionSvc>*)p);
8874  }
8875  static void deleteArray_SmartIFlEIConversionSvcgR(void *p) {
8876  delete [] ((::SmartIF<IConversionSvc>*)p);
8877  }
8878  static void destruct_SmartIFlEIConversionSvcgR(void *p) {
8879  typedef ::SmartIF<IConversionSvc> current_t;
8880  ((current_t*)p)->~current_t();
8881  }
8882 } // end of namespace ROOT for class ::SmartIF<IConversionSvc>
8883 
8884 namespace ROOT {
8885  // Wrappers around operator new
8886  static void *new_SmartIFlEIRndmGengR(void *p) {
8887  return p ? new(p) ::SmartIF<IRndmGen> : new ::SmartIF<IRndmGen>;
8888  }
8889  static void *newArray_SmartIFlEIRndmGengR(Long_t nElements, void *p) {
8890  return p ? new(p) ::SmartIF<IRndmGen>[nElements] : new ::SmartIF<IRndmGen>[nElements];
8891  }
8892  // Wrapper around operator delete
8893  static void delete_SmartIFlEIRndmGengR(void *p) {
8894  delete ((::SmartIF<IRndmGen>*)p);
8895  }
8896  static void deleteArray_SmartIFlEIRndmGengR(void *p) {
8897  delete [] ((::SmartIF<IRndmGen>*)p);
8898  }
8899  static void destruct_SmartIFlEIRndmGengR(void *p) {
8900  typedef ::SmartIF<IRndmGen> current_t;
8901  ((current_t*)p)->~current_t();
8902  }
8903 } // end of namespace ROOT for class ::SmartIF<IRndmGen>
8904 
8905 namespace ROOT {
8906  // Wrappers around operator new
8907  static void *new_SmartIFlEIChronoStatSvcgR(void *p) {
8908  return p ? new(p) ::SmartIF<IChronoStatSvc> : new ::SmartIF<IChronoStatSvc>;
8909  }
8910  static void *newArray_SmartIFlEIChronoStatSvcgR(Long_t nElements, void *p) {
8911  return p ? new(p) ::SmartIF<IChronoStatSvc>[nElements] : new ::SmartIF<IChronoStatSvc>[nElements];
8912  }
8913  // Wrapper around operator delete
8914  static void delete_SmartIFlEIChronoStatSvcgR(void *p) {
8915  delete ((::SmartIF<IChronoStatSvc>*)p);
8916  }
8917  static void deleteArray_SmartIFlEIChronoStatSvcgR(void *p) {
8918  delete [] ((::SmartIF<IChronoStatSvc>*)p);
8919  }
8920  static void destruct_SmartIFlEIChronoStatSvcgR(void *p) {
8921  typedef ::SmartIF<IChronoStatSvc> current_t;
8922  ((current_t*)p)->~current_t();
8923  }
8924 } // end of namespace ROOT for class ::SmartIF<IChronoStatSvc>
8925 
8926 namespace ROOT {
8927  // Wrappers around operator new
8928  static void *new_SmartIFlEIHistogramSvcgR(void *p) {
8929  return p ? new(p) ::SmartIF<IHistogramSvc> : new ::SmartIF<IHistogramSvc>;
8930  }
8931  static void *newArray_SmartIFlEIHistogramSvcgR(Long_t nElements, void *p) {
8932  return p ? new(p) ::SmartIF<IHistogramSvc>[nElements] : new ::SmartIF<IHistogramSvc>[nElements];
8933  }
8934  // Wrapper around operator delete
8935  static void delete_SmartIFlEIHistogramSvcgR(void *p) {
8936  delete ((::SmartIF<IHistogramSvc>*)p);
8937  }
8938  static void deleteArray_SmartIFlEIHistogramSvcgR(void *p) {
8939  delete [] ((::SmartIF<IHistogramSvc>*)p);
8940  }
8941  static void destruct_SmartIFlEIHistogramSvcgR(void *p) {
8942  typedef ::SmartIF<IHistogramSvc> current_t;
8943  ((current_t*)p)->~current_t();
8944  }
8945 } // end of namespace ROOT for class ::SmartIF<IHistogramSvc>
8946 
8947 namespace ROOT {
8948  // Wrappers around operator new
8949  static void *new_SmartIFlEINTupleSvcgR(void *p) {
8950  return p ? new(p) ::SmartIF<INTupleSvc> : new ::SmartIF<INTupleSvc>;
8951  }
8952  static void *newArray_SmartIFlEINTupleSvcgR(Long_t nElements, void *p) {
8953  return p ? new(p) ::SmartIF<INTupleSvc>[nElements] : new ::SmartIF<INTupleSvc>[nElements];
8954  }
8955  // Wrapper around operator delete
8956  static void delete_SmartIFlEINTupleSvcgR(void *p) {
8957  delete ((::SmartIF<INTupleSvc>*)p);
8958  }
8959  static void deleteArray_SmartIFlEINTupleSvcgR(void *p) {
8960  delete [] ((::SmartIF<INTupleSvc>*)p);
8961  }
8962  static void destruct_SmartIFlEINTupleSvcgR(void *p) {
8963  typedef ::SmartIF<INTupleSvc> current_t;
8964  ((current_t*)p)->~current_t();
8965  }
8966 } // end of namespace ROOT for class ::SmartIF<INTupleSvc>
8967 
8968 namespace ROOT {
8969  // Wrappers around operator new
8970  static void *new_SmartIFlEIRndmGenSvcgR(void *p) {
8971  return p ? new(p) ::SmartIF<IRndmGenSvc> : new ::SmartIF<IRndmGenSvc>;
8972  }
8973  static void *newArray_SmartIFlEIRndmGenSvcgR(Long_t nElements, void *p) {
8974  return p ? new(p) ::SmartIF<IRndmGenSvc>[nElements] : new ::SmartIF<IRndmGenSvc>[nElements];
8975  }
8976  // Wrapper around operator delete
8977  static void delete_SmartIFlEIRndmGenSvcgR(void *p) {
8978  delete ((::SmartIF<IRndmGenSvc>*)p);
8979  }
8980  static void deleteArray_SmartIFlEIRndmGenSvcgR(void *p) {
8981  delete [] ((::SmartIF<IRndmGenSvc>*)p);
8982  }
8983  static void destruct_SmartIFlEIRndmGenSvcgR(void *p) {
8984  typedef ::SmartIF<IRndmGenSvc> current_t;
8985  ((current_t*)p)->~current_t();
8986  }
8987 } // end of namespace ROOT for class ::SmartIF<IRndmGenSvc>
8988 
8989 namespace ROOT {
8990  // Wrappers around operator new
8991  static void *new_SmartIFlEIExceptionSvcgR(void *p) {
8992  return p ? new(p) ::SmartIF<IExceptionSvc> : new ::SmartIF<IExceptionSvc>;
8993  }
8994  static void *newArray_SmartIFlEIExceptionSvcgR(Long_t nElements, void *p) {
8995  return p ? new(p) ::SmartIF<IExceptionSvc>[nElements] : new ::SmartIF<IExceptionSvc>[nElements];
8996  }
8997  // Wrapper around operator delete
8998  static void delete_SmartIFlEIExceptionSvcgR(void *p) {
8999  delete ((::SmartIF<IExceptionSvc>*)p);
9000  }
9001  static void deleteArray_SmartIFlEIExceptionSvcgR(void *p) {
9002  delete [] ((::SmartIF<IExceptionSvc>*)p);
9003  }
9004  static void destruct_SmartIFlEIExceptionSvcgR(void *p) {
9005  typedef ::SmartIF<IExceptionSvc> current_t;
9006  ((current_t*)p)->~current_t();
9007  }
9008 } // end of namespace ROOT for class ::SmartIF<IExceptionSvc>
9009 
9010 namespace ROOT {
9011  // Wrappers around operator new
9012  static void *new_SmartIFlEITimelineSvcgR(void *p) {
9013  return p ? new(p) ::SmartIF<ITimelineSvc> : new ::SmartIF<ITimelineSvc>;
9014  }
9015  static void *newArray_SmartIFlEITimelineSvcgR(Long_t nElements, void *p) {
9016  return p ? new(p) ::SmartIF<ITimelineSvc>[nElements] : new ::SmartIF<ITimelineSvc>[nElements];
9017  }
9018  // Wrapper around operator delete
9019  static void delete_SmartIFlEITimelineSvcgR(void *p) {
9020  delete ((::SmartIF<ITimelineSvc>*)p);
9021  }
9022  static void deleteArray_SmartIFlEITimelineSvcgR(void *p) {
9023  delete [] ((::SmartIF<ITimelineSvc>*)p);
9024  }
9025  static void destruct_SmartIFlEITimelineSvcgR(void *p) {
9026  typedef ::SmartIF<ITimelineSvc> current_t;
9027  ((current_t*)p)->~current_t();
9028  }
9029 } // end of namespace ROOT for class ::SmartIF<ITimelineSvc>
9030 
9031 namespace ROOT {
9032  // Wrappers around operator new
9033  static void *new_SmartIFlEIHiveWhiteBoardgR(void *p) {
9034  return p ? new(p) ::SmartIF<IHiveWhiteBoard> : new ::SmartIF<IHiveWhiteBoard>;
9035  }
9036  static void *newArray_SmartIFlEIHiveWhiteBoardgR(Long_t nElements, void *p) {
9037  return p ? new(p) ::SmartIF<IHiveWhiteBoard>[nElements] : new ::SmartIF<IHiveWhiteBoard>[nElements];
9038  }
9039  // Wrapper around operator delete
9040  static void delete_SmartIFlEIHiveWhiteBoardgR(void *p) {
9041  delete ((::SmartIF<IHiveWhiteBoard>*)p);
9042  }
9043  static void deleteArray_SmartIFlEIHiveWhiteBoardgR(void *p) {
9044  delete [] ((::SmartIF<IHiveWhiteBoard>*)p);
9045  }
9046  static void destruct_SmartIFlEIHiveWhiteBoardgR(void *p) {
9047  typedef ::SmartIF<IHiveWhiteBoard> current_t;
9048  ((current_t*)p)->~current_t();
9049  }
9050 } // end of namespace ROOT for class ::SmartIF<IHiveWhiteBoard>
9051 
9052 namespace ROOT {
9053  // Wrappers around operator new
9054  static void *new_SmartIFlEIAlgExecStateSvcgR(void *p) {
9055  return p ? new(p) ::SmartIF<IAlgExecStateSvc> : new ::SmartIF<IAlgExecStateSvc>;
9056  }
9057  static void *newArray_SmartIFlEIAlgExecStateSvcgR(Long_t nElements, void *p) {
9058  return p ? new(p) ::SmartIF<IAlgExecStateSvc>[nElements] : new ::SmartIF<IAlgExecStateSvc>[nElements];
9059  }
9060  // Wrapper around operator delete
9061  static void delete_SmartIFlEIAlgExecStateSvcgR(void *p) {
9062  delete ((::SmartIF<IAlgExecStateSvc>*)p);
9063  }
9064  static void deleteArray_SmartIFlEIAlgExecStateSvcgR(void *p) {
9065  delete [] ((::SmartIF<IAlgExecStateSvc>*)p);
9066  }
9067  static void destruct_SmartIFlEIAlgExecStateSvcgR(void *p) {
9068  typedef ::SmartIF<IAlgExecStateSvc> current_t;
9069  ((current_t*)p)->~current_t();
9070  }
9071 } // end of namespace ROOT for class ::SmartIF<IAlgExecStateSvc>
9072 
9073 namespace ROOT {
9074  // Wrappers around operator new
9075  static void *new_SmartIFlEISvcManagergR(void *p) {
9076  return p ? new(p) ::SmartIF<ISvcManager> : new ::SmartIF<ISvcManager>;
9077  }
9078  static void *newArray_SmartIFlEISvcManagergR(Long_t nElements, void *p) {
9079  return p ? new(p) ::SmartIF<ISvcManager>[nElements] : new ::SmartIF<ISvcManager>[nElements];
9080  }
9081  // Wrapper around operator delete
9082  static void delete_SmartIFlEISvcManagergR(void *p) {
9083  delete ((::SmartIF<ISvcManager>*)p);
9084  }
9085  static void deleteArray_SmartIFlEISvcManagergR(void *p) {
9086  delete [] ((::SmartIF<ISvcManager>*)p);
9087  }
9088  static void destruct_SmartIFlEISvcManagergR(void *p) {
9089  typedef ::SmartIF<ISvcManager> current_t;
9090  ((current_t*)p)->~current_t();
9091  }
9092 } // end of namespace ROOT for class ::SmartIF<ISvcManager>
9093 
9094 namespace ROOT {
9095  // Wrappers around operator new
9096  static void *new_SmartIFlEIIncidentSvcgR(void *p) {
9097  return p ? new(p) ::SmartIF<IIncidentSvc> : new ::SmartIF<IIncidentSvc>;
9098  }
9099  static void *newArray_SmartIFlEIIncidentSvcgR(Long_t nElements, void *p) {
9100  return p ? new(p) ::SmartIF<IIncidentSvc>[nElements] : new ::SmartIF<IIncidentSvc>[nElements];
9101  }
9102  // Wrapper around operator delete
9103  static void delete_SmartIFlEIIncidentSvcgR(void *p) {
9104  delete ((::SmartIF<IIncidentSvc>*)p);
9105  }
9106  static void deleteArray_SmartIFlEIIncidentSvcgR(void *p) {
9107  delete [] ((::SmartIF<IIncidentSvc>*)p);
9108  }
9109  static void destruct_SmartIFlEIIncidentSvcgR(void *p) {
9110  typedef ::SmartIF<IIncidentSvc> current_t;
9111  ((current_t*)p)->~current_t();
9112  }
9113 } // end of namespace ROOT for class ::SmartIF<IIncidentSvc>
9114 
9115 namespace ROOT {
9116  // Wrappers around operator new
9117  static void *new_SmartIFlEIEvtSelectorgR(void *p) {
9118  return p ? new(p) ::SmartIF<IEvtSelector> : new ::SmartIF<IEvtSelector>;
9119  }
9120  static void *newArray_SmartIFlEIEvtSelectorgR(Long_t nElements, void *p) {
9121  return p ? new(p) ::SmartIF<IEvtSelector>[nElements] : new ::SmartIF<IEvtSelector>[nElements];
9122  }
9123  // Wrapper around operator delete
9124  static void delete_SmartIFlEIEvtSelectorgR(void *p) {
9125  delete ((::SmartIF<IEvtSelector>*)p);
9126  }
9127  static void deleteArray_SmartIFlEIEvtSelectorgR(void *p) {
9128  delete [] ((::SmartIF<IEvtSelector>*)p);
9129  }
9130  static void destruct_SmartIFlEIEvtSelectorgR(void *p) {
9131  typedef ::SmartIF<IEvtSelector> current_t;
9132  ((current_t*)p)->~current_t();
9133  }
9134 } // end of namespace ROOT for class ::SmartIF<IEvtSelector>
9135 
9136 namespace ROOT {
9137  // Wrappers around operator new
9138  static void *new_SmartIFlEISelectStatementgR(void *p) {
9139  return p ? new(p) ::SmartIF<ISelectStatement> : new ::SmartIF<ISelectStatement>;
9140  }
9141  static void *newArray_SmartIFlEISelectStatementgR(Long_t nElements, void *p) {
9142  return p ? new(p) ::SmartIF<ISelectStatement>[nElements] : new ::SmartIF<ISelectStatement>[nElements];
9143  }
9144  // Wrapper around operator delete
9145  static void delete_SmartIFlEISelectStatementgR(void *p) {
9146  delete ((::SmartIF<ISelectStatement>*)p);
9147  }
9148  static void deleteArray_SmartIFlEISelectStatementgR(void *p) {
9149  delete [] ((::SmartIF<ISelectStatement>*)p);
9150  }
9151  static void destruct_SmartIFlEISelectStatementgR(void *p) {
9152  typedef ::SmartIF<ISelectStatement> current_t;
9153  ((current_t*)p)->~current_t();
9154  }
9155 } // end of namespace ROOT for class ::SmartIF<ISelectStatement>
9156 
9157 namespace ROOT {
9158  // Wrapper around operator delete
9159  static void delete_ISvcManager(void *p) {
9160  delete ((::ISvcManager*)p);
9161  }
9162  static void deleteArray_ISvcManager(void *p) {
9163  delete [] ((::ISvcManager*)p);
9164  }
9165  static void destruct_ISvcManager(void *p) {
9166  typedef ::ISvcManager current_t;
9167  ((current_t*)p)->~current_t();
9168  }
9169 } // end of namespace ROOT for class ::ISvcManager
9170 
9171 namespace ROOT {
9172  // Wrapper around operator delete
9173  static void delete_ISvcLocator(void *p) {
9174  delete ((::ISvcLocator*)p);
9175  }
9176  static void deleteArray_ISvcLocator(void *p) {
9177  delete [] ((::ISvcLocator*)p);
9178  }
9179  static void destruct_ISvcLocator(void *p) {
9180  typedef ::ISvcLocator current_t;
9181  ((current_t*)p)->~current_t();
9182  }
9183 } // end of namespace ROOT for class ::ISvcLocator
9184 
9185 namespace ROOT {
9186  // Wrapper around operator delete
9187  static void delete_IAlgTool(void *p) {
9188  delete ((::IAlgTool*)p);
9189  }
9190  static void deleteArray_IAlgTool(void *p) {
9191  delete [] ((::IAlgTool*)p);
9192  }
9193  static void destruct_IAlgTool(void *p) {
9194  typedef ::IAlgTool current_t;
9195  ((current_t*)p)->~current_t();
9196  }
9197 } // end of namespace ROOT for class ::IAlgTool
9198 
9199 namespace ROOT {
9200  // Wrapper around operator delete
9201  static void delete_IAuditor(void *p) {
9202  delete ((::IAuditor*)p);
9203  }
9204  static void deleteArray_IAuditor(void *p) {
9205  delete [] ((::IAuditor*)p);
9206  }
9207  static void destruct_IAuditor(void *p) {
9208  typedef ::IAuditor current_t;
9209  ((current_t*)p)->~current_t();
9210  }
9211 } // end of namespace ROOT for class ::IAuditor
9212 
9213 namespace ROOT {
9214  // Wrapper around operator delete
9215  static void delete_IAuditorSvc(void *p) {
9216  delete ((::IAuditorSvc*)p);
9217  }
9218  static void deleteArray_IAuditorSvc(void *p) {
9219  delete [] ((::IAuditorSvc*)p);
9220  }
9221  static void destruct_IAuditorSvc(void *p) {
9222  typedef ::IAuditorSvc current_t;
9223  ((current_t*)p)->~current_t();
9224  }
9225 } // end of namespace ROOT for class ::IAuditorSvc
9226 
9227 namespace ROOT {
9228  // Wrapper around operator delete
9229  static void delete_IDataProviderSvc(void *p) {
9230  delete ((::IDataProviderSvc*)p);
9231  }
9232  static void deleteArray_IDataProviderSvc(void *p) {
9233  delete [] ((::IDataProviderSvc*)p);
9234  }
9235  static void destruct_IDataProviderSvc(void *p) {
9236  typedef ::IDataProviderSvc current_t;
9237  ((current_t*)p)->~current_t();
9238  }
9239 } // end of namespace ROOT for class ::IDataProviderSvc
9240 
9241 namespace ROOT {
9242  // Wrapper around operator delete
9243  static void delete_IMonitorSvc(void *p) {
9244  delete ((::IMonitorSvc*)p);
9245  }
9246  static void deleteArray_IMonitorSvc(void *p) {
9247  delete [] ((::IMonitorSvc*)p);
9248  }
9249  static void destruct_IMonitorSvc(void *p) {
9250  typedef ::IMonitorSvc current_t;
9251  ((current_t*)p)->~current_t();
9252  }
9253 } // end of namespace ROOT for class ::IMonitorSvc
9254 
9255 namespace ROOT {
9256  // Wrapper around operator delete
9257  static void delete_IProperty(void *p) {
9258  delete ((::IProperty*)p);
9259  }
9260  static void deleteArray_IProperty(void *p) {
9261  delete [] ((::IProperty*)p);
9262  }
9263  static void destruct_IProperty(void *p) {
9264  typedef ::IProperty current_t;
9265  ((current_t*)p)->~current_t();
9266  }
9267 } // end of namespace ROOT for class ::IProperty
9268 
9269 namespace ROOT {
9270  // Wrapper around operator delete
9271  static void delete_IToolSvc(void *p) {
9272  delete ((::IToolSvc*)p);
9273  }
9274  static void deleteArray_IToolSvc(void *p) {
9275  delete [] ((::IToolSvc*)p);
9276  }
9277  static void destruct_IToolSvc(void *p) {
9278  typedef ::IToolSvc current_t;
9279  ((current_t*)p)->~current_t();
9280  }
9281 } // end of namespace ROOT for class ::IToolSvc
9282 
9283 namespace ROOT {
9284  // Wrapper around operator delete
9285  static void delete_GaudicLcLDetailscLcLPropertyBase(void *p) {
9286  delete ((::Gaudi::Details::PropertyBase*)p);
9287  }
9288  static void deleteArray_GaudicLcLDetailscLcLPropertyBase(void *p) {
9289  delete [] ((::Gaudi::Details::PropertyBase*)p);
9290  }
9291  static void destruct_GaudicLcLDetailscLcLPropertyBase(void *p) {
9292  typedef ::Gaudi::Details::PropertyBase current_t;
9293  ((current_t*)p)->~current_t();
9294  }
9295 } // end of namespace ROOT for class ::Gaudi::Details::PropertyBase
9296 
9297 namespace ROOT {
9298  // Wrapper around operator delete
9299  static void delete_GaudiHandleProperty(void *p) {
9300  delete ((::GaudiHandleProperty*)p);
9301  }
9302  static void deleteArray_GaudiHandleProperty(void *p) {
9303  delete [] ((::GaudiHandleProperty*)p);
9304  }
9305  static void destruct_GaudiHandleProperty(void *p) {
9306  typedef ::GaudiHandleProperty current_t;
9307  ((current_t*)p)->~current_t();
9308  }
9309 } // end of namespace ROOT for class ::GaudiHandleProperty
9310 
9311 namespace ROOT {
9312  // Wrapper around operator delete
9313  static void delete_GaudiHandleArrayProperty(void *p) {
9314  delete ((::GaudiHandleArrayProperty*)p);
9315  }
9316  static void deleteArray_GaudiHandleArrayProperty(void *p) {
9317  delete [] ((::GaudiHandleArrayProperty*)p);
9318  }
9319  static void destruct_GaudiHandleArrayProperty(void *p) {
9320  typedef ::GaudiHandleArrayProperty current_t;
9321  ((current_t*)p)->~current_t();
9322  }
9323 } // end of namespace ROOT for class ::GaudiHandleArrayProperty
9324 
9325 namespace ROOT {
9326  // Wrapper around operator delete
9327  static void delete_DataObjectHandleProperty(void *p) {
9328  delete ((::DataObjectHandleProperty*)p);
9329  }
9330  static void deleteArray_DataObjectHandleProperty(void *p) {
9331  delete [] ((::DataObjectHandleProperty*)p);
9332  }
9333  static void destruct_DataObjectHandleProperty(void *p) {
9334  typedef ::DataObjectHandleProperty current_t;
9335  ((current_t*)p)->~current_t();
9336  }
9337 } // end of namespace ROOT for class ::DataObjectHandleProperty
9338 
9339 namespace ROOT {
9340  // Wrapper around operator delete
9341  static void delete_GaudiHandleInfo(void *p) {
9342  delete ((::GaudiHandleInfo*)p);
9343  }
9344  static void deleteArray_GaudiHandleInfo(void *p) {
9345  delete [] ((::GaudiHandleInfo*)p);
9346  }
9347  static void destruct_GaudiHandleInfo(void *p) {
9348  typedef ::GaudiHandleInfo current_t;
9349  ((current_t*)p)->~current_t();
9350  }
9351 } // end of namespace ROOT for class ::GaudiHandleInfo
9352 
9353 namespace ROOT {
9354  // Wrapper around operator delete
9355  static void delete_GaudiHandleBase(void *p) {
9356  delete ((::GaudiHandleBase*)p);
9357  }
9358  static void deleteArray_GaudiHandleBase(void *p) {
9359  delete [] ((::GaudiHandleBase*)p);
9360  }
9361  static void destruct_GaudiHandleBase(void *p) {
9362  typedef ::GaudiHandleBase current_t;
9363  ((current_t*)p)->~current_t();
9364  }
9365 } // end of namespace ROOT for class ::GaudiHandleBase
9366 
9367 namespace ROOT {
9368  // Wrapper around operator delete
9369  static void delete_GaudiHandleArrayBase(void *p) {
9370  delete ((::GaudiHandleArrayBase*)p);
9371  }
9372  static void deleteArray_GaudiHandleArrayBase(void *p) {
9373  delete [] ((::GaudiHandleArrayBase*)p);
9374  }
9375  static void destruct_GaudiHandleArrayBase(void *p) {
9376  typedef ::GaudiHandleArrayBase current_t;
9377  ((current_t*)p)->~current_t();
9378  }
9379 } // end of namespace ROOT for class ::GaudiHandleArrayBase
9380 
9381 namespace ROOT {
9382  // Wrapper around operator delete
9383  static void delete_AlgTool(void *p) {
9384  delete ((::AlgTool*)p);
9385  }
9386  static void deleteArray_AlgTool(void *p) {
9387  delete [] ((::AlgTool*)p);
9388  }
9389  static void destruct_AlgTool(void *p) {
9390  typedef ::AlgTool current_t;
9391  ((current_t*)p)->~current_t();
9392  }
9393 } // end of namespace ROOT for class ::AlgTool
9394 
9395 namespace ROOT {
9396  // Wrapper around operator delete
9397  static void delete_IAlgorithm(void *p) {
9398  delete ((::IAlgorithm*)p);
9399  }
9400  static void deleteArray_IAlgorithm(void *p) {
9401  delete [] ((::IAlgorithm*)p);
9402  }
9403  static void destruct_IAlgorithm(void *p) {
9404  typedef ::IAlgorithm current_t;
9405  ((current_t*)p)->~current_t();
9406  }
9407 } // end of namespace ROOT for class ::IAlgorithm
9408 
9409 namespace ROOT {
9410  // Wrapper around operator delete
9411  static void delete_IAlgContextSvc(void *p) {
9412  delete ((::IAlgContextSvc*)p);
9413  }
9414  static void deleteArray_IAlgContextSvc(void *p) {
9415  delete [] ((::IAlgContextSvc*)p);
9416  }
9417  static void destruct_IAlgContextSvc(void *p) {
9418  typedef ::IAlgContextSvc current_t;
9419  ((current_t*)p)->~current_t();
9420  }
9421 } // end of namespace ROOT for class ::IAlgContextSvc
9422 
9423 namespace ROOT {
9424  // Wrapper around operator delete
9425  static void delete_IChronoSvc(void *p) {
9426  delete ((::IChronoSvc*)p);
9427  }
9428  static void deleteArray_IChronoSvc(void *p) {
9429  delete [] ((::IChronoSvc*)p);
9430  }
9431  static void destruct_IChronoSvc(void *p) {
9432  typedef ::IChronoSvc current_t;
9433  ((current_t*)p)->~current_t();
9434  }
9435 } // end of namespace ROOT for class ::IChronoSvc
9436 
9437 namespace ROOT {
9438  // Wrapper around operator delete
9439  static void delete_IStatSvc(void *p) {
9440  delete ((::IStatSvc*)p);
9441  }
9442  static void deleteArray_IStatSvc(void *p) {
9443  delete [] ((::IStatSvc*)p);
9444  }
9445  static void destruct_IStatSvc(void *p) {
9446  typedef ::IStatSvc current_t;
9447  ((current_t*)p)->~current_t();
9448  }
9449 } // end of namespace ROOT for class ::IStatSvc
9450 
9451 namespace ROOT {
9452  // Wrapper around operator delete
9453  static void delete_IChronoStatSvc(void *p) {
9454  delete ((::IChronoStatSvc*)p);
9455  }
9456  static void deleteArray_IChronoStatSvc(void *p) {
9457  delete [] ((::IChronoStatSvc*)p);
9458  }
9459  static void destruct_IChronoStatSvc(void *p) {
9460  typedef ::IChronoStatSvc current_t;
9461  ((current_t*)p)->~current_t();
9462  }
9463 } // end of namespace ROOT for class ::IChronoStatSvc
9464 
9465 namespace ROOT {
9466  // Wrapper around operator delete
9467  static void delete_IConverter(void *p) {
9468  delete ((::IConverter*)p);
9469  }
9470  static void deleteArray_IConverter(void *p) {
9471  delete [] ((::IConverter*)p);
9472  }
9473  static void destruct_IConverter(void *p) {
9474  typedef ::IConverter current_t;
9475  ((current_t*)p)->~current_t();
9476  }
9477 } // end of namespace ROOT for class ::IConverter
9478 
9479 namespace ROOT {
9480  // Wrapper around operator delete
9481  static void delete_IConversionSvc(void *p) {
9482  delete ((::IConversionSvc*)p);
9483  }
9484  static void deleteArray_IConversionSvc(void *p) {
9485  delete [] ((::IConversionSvc*)p);
9486  }
9487  static void destruct_IConversionSvc(void *p) {
9488  typedef ::IConversionSvc current_t;
9489  ((current_t*)p)->~current_t();
9490  }
9491 } // end of namespace ROOT for class ::IConversionSvc
9492 
9493 namespace ROOT {
9494  // Wrapper around operator delete
9495  static void delete_IExceptionSvc(void *p) {
9496  delete ((::IExceptionSvc*)p);
9497  }
9498  static void deleteArray_IExceptionSvc(void *p) {
9499  delete [] ((::IExceptionSvc*)p);
9500  }
9501  static void destruct_IExceptionSvc(void *p) {
9502  typedef ::IExceptionSvc current_t;
9503  ((current_t*)p)->~current_t();
9504  }
9505 } // end of namespace ROOT for class ::IExceptionSvc
9506 
9507 namespace ROOT {
9508  // Wrapper around operator delete
9509  static void delete_IHistogramSvc(void *p) {
9510  delete ((::IHistogramSvc*)p);
9511  }
9512  static void deleteArray_IHistogramSvc(void *p) {
9513  delete [] ((::IHistogramSvc*)p);
9514  }
9515  static void destruct_IHistogramSvc(void *p) {
9516  typedef ::IHistogramSvc current_t;
9517  ((current_t*)p)->~current_t();
9518  }
9519 } // end of namespace ROOT for class ::IHistogramSvc
9520 
9521 namespace ROOT {
9522  // Wrapper around operator delete
9523  static void delete_INTupleSvc(void *p) {
9524  delete ((::INTupleSvc*)p);
9525  }
9526  static void deleteArray_INTupleSvc(void *p) {
9527  delete [] ((::INTupleSvc*)p);
9528  }
9529  static void destruct_INTupleSvc(void *p) {
9530  typedef ::INTupleSvc current_t;
9531  ((current_t*)p)->~current_t();
9532  }
9533 } // end of namespace ROOT for class ::INTupleSvc
9534 
9535 namespace ROOT {
9536  // Wrapper around operator delete
9537  static void delete_IRndmGen(void *p) {
9538  delete ((::IRndmGen*)p);
9539  }
9540  static void deleteArray_IRndmGen(void *p) {
9541  delete [] ((::IRndmGen*)p);
9542  }
9543  static void destruct_IRndmGen(void *p) {
9544  typedef ::IRndmGen current_t;
9545  ((current_t*)p)->~current_t();
9546  }
9547 } // end of namespace ROOT for class ::IRndmGen
9548 
9549 namespace ROOT {
9550  // Wrapper around operator delete
9551  static void delete_IRndmGencLcLParam(void *p) {
9552  delete ((::IRndmGen::Param*)p);
9553  }
9554  static void deleteArray_IRndmGencLcLParam(void *p) {
9555  delete [] ((::IRndmGen::Param*)p);
9556  }
9557  static void destruct_IRndmGencLcLParam(void *p) {
9558  typedef ::IRndmGen::Param current_t;
9559  ((current_t*)p)->~current_t();
9560  }
9561 } // end of namespace ROOT for class ::IRndmGen::Param
9562 
9563 namespace ROOT {
9564  // Wrapper around operator delete
9565  static void delete_IRndmGenSvc(void *p) {
9566  delete ((::IRndmGenSvc*)p);
9567  }
9568  static void deleteArray_IRndmGenSvc(void *p) {
9569  delete [] ((::IRndmGenSvc*)p);
9570  }
9571  static void destruct_IRndmGenSvc(void *p) {
9572  typedef ::IRndmGenSvc current_t;
9573  ((current_t*)p)->~current_t();
9574  }
9575 } // end of namespace ROOT for class ::IRndmGenSvc
9576 
9577 namespace ROOT {
9578  // Wrapper around operator delete
9579  static void delete_Algorithm(void *p) {
9580  delete ((::Algorithm*)p);
9581  }
9582  static void deleteArray_Algorithm(void *p) {
9583  delete [] ((::Algorithm*)p);
9584  }
9585  static void destruct_Algorithm(void *p) {
9586  typedef ::Algorithm current_t;
9587  ((current_t*)p)->~current_t();
9588  }
9589 } // end of namespace ROOT for class ::Algorithm
9590 
9591 namespace ROOT {
9592  // Wrappers around operator new
9593  static void *new_DataObject(void *p) {
9594  return p ? new(p) ::DataObject : new ::DataObject;
9595  }
9596  static void *newArray_DataObject(Long_t nElements, void *p) {
9597  return p ? new(p) ::DataObject[nElements] : new ::DataObject[nElements];
9598  }
9599  // Wrapper around operator delete
9600  static void delete_DataObject(void *p) {
9601  delete ((::DataObject*)p);
9602  }
9603  static void deleteArray_DataObject(void *p) {
9604  delete [] ((::DataObject*)p);
9605  }
9606  static void destruct_DataObject(void *p) {
9607  typedef ::DataObject current_t;
9608  ((current_t*)p)->~current_t();
9609  }
9610 } // end of namespace ROOT for class ::DataObject
9611 
9612 namespace ROOT {
9613  // Wrapper around operator delete
9614  static void delete_ObjectContainerBase(void *p) {
9615  delete ((::ObjectContainerBase*)p);
9616  }
9617  static void deleteArray_ObjectContainerBase(void *p) {
9618  delete [] ((::ObjectContainerBase*)p);
9619  }
9620  static void destruct_ObjectContainerBase(void *p) {
9621  typedef ::ObjectContainerBase current_t;
9622  ((current_t*)p)->~current_t();
9623  }
9624 } // end of namespace ROOT for class ::ObjectContainerBase
9625 
9626 namespace ROOT {
9627 } // end of namespace ROOT for class ::ContainedObject
9628 
9629 namespace ROOT {
9630  // Wrapper around operator delete
9631  static void delete_IDataStreamTool(void *p) {
9632  delete ((::IDataStreamTool*)p);
9633  }
9634  static void deleteArray_IDataStreamTool(void *p) {
9635  delete [] ((::IDataStreamTool*)p);
9636  }
9637  static void destruct_IDataStreamTool(void *p) {
9638  typedef ::IDataStreamTool current_t;
9639  ((current_t*)p)->~current_t();
9640  }
9641 } // end of namespace ROOT for class ::IDataStreamTool
9642 
9643 namespace ROOT {
9644  // Wrapper around operator delete
9645  static void delete_IOpaqueAddress(void *p) {
9646  delete ((::IOpaqueAddress*)p);
9647  }
9648  static void deleteArray_IOpaqueAddress(void *p) {
9649  delete [] ((::IOpaqueAddress*)p);
9650  }
9651  static void destruct_IOpaqueAddress(void *p) {
9652  typedef ::IOpaqueAddress current_t;
9653  ((current_t*)p)->~current_t();
9654  }
9655 } // end of namespace ROOT for class ::IOpaqueAddress
9656 
9657 namespace ROOT {
9658  // Wrapper around operator delete
9659  static void delete_IEvtSelector(void *p) {
9660  delete ((::IEvtSelector*)p);
9661  }
9662  static void deleteArray_IEvtSelector(void *p) {
9663  delete [] ((::IEvtSelector*)p);
9664  }
9665  static void destruct_IEvtSelector(void *p) {
9666  typedef ::IEvtSelector current_t;
9667  ((current_t*)p)->~current_t();
9668  }
9669 } // end of namespace ROOT for class ::IEvtSelector
9670 
9671 namespace ROOT {
9672  // Wrapper around operator delete
9673  static void delete_Incident(void *p) {
9674  delete ((::Incident*)p);
9675  }
9676  static void deleteArray_Incident(void *p) {
9677  delete [] ((::Incident*)p);
9678  }
9679  static void destruct_Incident(void *p) {
9680  typedef ::Incident current_t;
9681  ((current_t*)p)->~current_t();
9682  }
9683 } // end of namespace ROOT for class ::Incident
9684 
9685 namespace ROOT {
9686  // Wrapper around operator delete
9687  static void delete_IIncidentSvc(void *p) {
9688  delete ((::IIncidentSvc*)p);
9689  }
9690  static void deleteArray_IIncidentSvc(void *p) {
9691  delete [] ((::IIncidentSvc*)p);
9692  }
9693  static void destruct_IIncidentSvc(void *p) {
9694  typedef ::IIncidentSvc current_t;
9695  ((current_t*)p)->~current_t();
9696  }
9697 } // end of namespace ROOT for class ::IIncidentSvc
9698 
9699 namespace ROOT {
9700 } // end of namespace ROOT for class ::Service
9701 
9702 namespace ROOT {
9703  // Wrappers around operator new
9704  static void *new_GenericAddress(void *p) {
9705  return p ? new(p) ::GenericAddress : new ::GenericAddress;
9706  }
9707  static void *newArray_GenericAddress(Long_t nElements, void *p) {
9708  return p ? new(p) ::GenericAddress[nElements] : new ::GenericAddress[nElements];
9709  }
9710  // Wrapper around operator delete
9711  static void delete_GenericAddress(void *p) {
9712  delete ((::GenericAddress*)p);
9713  }
9714  static void deleteArray_GenericAddress(void *p) {
9715  delete [] ((::GenericAddress*)p);
9716  }
9717  static void destruct_GenericAddress(void *p) {
9718  typedef ::GenericAddress current_t;
9719  ((current_t*)p)->~current_t();
9720  }
9721 } // end of namespace ROOT for class ::GenericAddress
9722 
9723 namespace ROOT {
9724  // Wrappers around operator new
9725  static void *new_KeyedObjectlEintgR(void *p) {
9726  return p ? new(p) ::KeyedObject<int> : new ::KeyedObject<int>;
9727  }
9728  static void *newArray_KeyedObjectlEintgR(Long_t nElements, void *p) {
9729  return p ? new(p) ::KeyedObject<int>[nElements] : new ::KeyedObject<int>[nElements];
9730  }
9731  // Wrapper around operator delete
9732  static void delete_KeyedObjectlEintgR(void *p) {
9733  delete ((::KeyedObject<int>*)p);
9734  }
9735  static void deleteArray_KeyedObjectlEintgR(void *p) {
9736  delete [] ((::KeyedObject<int>*)p);
9737  }
9738  static void destruct_KeyedObjectlEintgR(void *p) {
9739  typedef ::KeyedObject<int> current_t;
9740  ((current_t*)p)->~current_t();
9741  }
9742 } // end of namespace ROOT for class ::KeyedObject<int>
9743 
9744 namespace ROOT {
9745  // Wrappers around operator new
9746  static void *new_KeyedObjectlEunsignedsPintgR(void *p) {
9747  return p ? new(p) ::KeyedObject<unsigned int> : new ::KeyedObject<unsigned int>;
9748  }
9749  static void *newArray_KeyedObjectlEunsignedsPintgR(Long_t nElements, void *p) {
9750  return p ? new(p) ::KeyedObject<unsigned int>[nElements] : new ::KeyedObject<unsigned int>[nElements];
9751  }
9752  // Wrapper around operator delete
9753  static void delete_KeyedObjectlEunsignedsPintgR(void *p) {
9754  delete ((::KeyedObject<unsigned int>*)p);
9755  }
9756  static void deleteArray_KeyedObjectlEunsignedsPintgR(void *p) {
9757  delete [] ((::KeyedObject<unsigned int>*)p);
9758  }
9759  static void destruct_KeyedObjectlEunsignedsPintgR(void *p) {
9760  typedef ::KeyedObject<unsigned int> current_t;
9761  ((current_t*)p)->~current_t();
9762  }
9763 } // end of namespace ROOT for class ::KeyedObject<unsigned int>
9764 
9765 namespace ROOT {
9766  // Wrappers around operator new
9767  static void *new_KeyedObjectlElonggR(void *p) {
9768  return p ? new(p) ::KeyedObject<long> : new ::KeyedObject<long>;
9769  }
9770  static void *newArray_KeyedObjectlElonggR(Long_t nElements, void *p) {
9771  return p ? new(p) ::KeyedObject<long>[nElements] : new ::KeyedObject<long>[nElements];
9772  }
9773  // Wrapper around operator delete
9774  static void delete_KeyedObjectlElonggR(void *p) {
9775  delete ((::KeyedObject<long>*)p);
9776  }
9777  static void deleteArray_KeyedObjectlElonggR(void *p) {
9778  delete [] ((::KeyedObject<long>*)p);
9779  }
9780  static void destruct_KeyedObjectlElonggR(void *p) {
9781  typedef ::KeyedObject<long> current_t;
9782  ((current_t*)p)->~current_t();
9783  }
9784 } // end of namespace ROOT for class ::KeyedObject<long>
9785 
9786 namespace ROOT {
9787  // Wrappers around operator new
9788  static void *new_KeyedObjectlEunsignedsPlonggR(void *p) {
9789  return p ? new(p) ::KeyedObject<unsigned long> : new ::KeyedObject<unsigned long>;
9790  }
9791  static void *newArray_KeyedObjectlEunsignedsPlonggR(Long_t nElements, void *p) {
9792  return p ? new(p) ::KeyedObject<unsigned long>[nElements] : new ::KeyedObject<unsigned long>[nElements];
9793  }
9794  // Wrapper around operator delete
9795  static void delete_KeyedObjectlEunsignedsPlonggR(void *p) {
9796  delete ((::KeyedObject<unsigned long>*)p);
9797  }
9798  static void deleteArray_KeyedObjectlEunsignedsPlonggR(void *p) {
9799  delete [] ((::KeyedObject<unsigned long>*)p);
9800  }
9801  static void destruct_KeyedObjectlEunsignedsPlonggR(void *p) {
9802  typedef ::KeyedObject<unsigned long> current_t;
9803  ((current_t*)p)->~current_t();
9804  }
9805 } // end of namespace ROOT for class ::KeyedObject<unsigned long>
9806 
9807 namespace ROOT {
9808  // Wrappers around operator new
9809  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p) {
9810  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::map> : new ::Containers::KeyedObjectManager<Containers::map>;
9811  }
9812  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(Long_t nElements, void *p) {
9813  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::map>[nElements] : new ::Containers::KeyedObjectManager<Containers::map>[nElements];
9814  }
9815  // Wrapper around operator delete
9816  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p) {
9817  delete ((::Containers::KeyedObjectManager<Containers::map>*)p);
9818  }
9819  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p) {
9820  delete [] ((::Containers::KeyedObjectManager<Containers::map>*)p);
9821  }
9822  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLmapgR(void *p) {
9823  typedef ::Containers::KeyedObjectManager<Containers::map> current_t;
9824  ((current_t*)p)->~current_t();
9825  }
9826 } // end of namespace ROOT for class ::Containers::KeyedObjectManager<Containers::map>
9827 
9828 namespace ROOT {
9829  // Wrappers around operator new
9830  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p) {
9831  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::hashmap> : new ::Containers::KeyedObjectManager<Containers::hashmap>;
9832  }
9833  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(Long_t nElements, void *p) {
9834  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::hashmap>[nElements] : new ::Containers::KeyedObjectManager<Containers::hashmap>[nElements];
9835  }
9836  // Wrapper around operator delete
9837  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p) {
9838  delete ((::Containers::KeyedObjectManager<Containers::hashmap>*)p);
9839  }
9840  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p) {
9841  delete [] ((::Containers::KeyedObjectManager<Containers::hashmap>*)p);
9842  }
9843  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLhashmapgR(void *p) {
9844  typedef ::Containers::KeyedObjectManager<Containers::hashmap> current_t;
9845  ((current_t*)p)->~current_t();
9846  }
9847 } // end of namespace ROOT for class ::Containers::KeyedObjectManager<Containers::hashmap>
9848 
9849 namespace ROOT {
9850  // Wrappers around operator new
9851  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p) {
9852  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::vector> : new ::Containers::KeyedObjectManager<Containers::vector>;
9853  }
9854  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(Long_t nElements, void *p) {
9855  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::vector>[nElements] : new ::Containers::KeyedObjectManager<Containers::vector>[nElements];
9856  }
9857  // Wrapper around operator delete
9858  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p) {
9859  delete ((::Containers::KeyedObjectManager<Containers::vector>*)p);
9860  }
9861  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p) {
9862  delete [] ((::Containers::KeyedObjectManager<Containers::vector>*)p);
9863  }
9864  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLvectorgR(void *p) {
9865  typedef ::Containers::KeyedObjectManager<Containers::vector> current_t;
9866  ((current_t*)p)->~current_t();
9867  }
9868 } // end of namespace ROOT for class ::Containers::KeyedObjectManager<Containers::vector>
9869 
9870 namespace ROOT {
9871  // Wrappers around operator new
9872  static void *new_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p) {
9873  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::array> : new ::Containers::KeyedObjectManager<Containers::array>;
9874  }
9875  static void *newArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(Long_t nElements, void *p) {
9876  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Containers::KeyedObjectManager<Containers::array>[nElements] : new ::Containers::KeyedObjectManager<Containers::array>[nElements];
9877  }
9878  // Wrapper around operator delete
9879  static void delete_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p) {
9880  delete ((::Containers::KeyedObjectManager<Containers::array>*)p);
9881  }
9882  static void deleteArray_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p) {
9883  delete [] ((::Containers::KeyedObjectManager<Containers::array>*)p);
9884  }
9885  static void destruct_ContainerscLcLKeyedObjectManagerlEContainerscLcLarraygR(void *p) {
9886  typedef ::Containers::KeyedObjectManager<Containers::array> current_t;
9887  ((current_t*)p)->~current_t();
9888  }
9889 } // end of namespace ROOT for class ::Containers::KeyedObjectManager<Containers::array>
9890 
9891 namespace ROOT {
9892  // Wrappers around operator new
9893  static void *new_LinkManager(void *p) {
9894  return p ? new(p) ::LinkManager : new ::LinkManager;
9895  }
9896  static void *newArray_LinkManager(Long_t nElements, void *p) {
9897  return p ? new(p) ::LinkManager[nElements] : new ::LinkManager[nElements];
9898  }
9899  // Wrapper around operator delete
9900  static void delete_LinkManager(void *p) {
9901  delete ((::LinkManager*)p);
9902  }
9903  static void deleteArray_LinkManager(void *p) {
9904  delete [] ((::LinkManager*)p);
9905  }
9906  static void destruct_LinkManager(void *p) {
9907  typedef ::LinkManager current_t;
9908  ((current_t*)p)->~current_t();
9909  }
9910 } // end of namespace ROOT for class ::LinkManager
9911 
9912 namespace ROOT {
9913  // Wrappers around operator new
9914  static void *new_LinkManagercLcLLink(void *p) {
9915  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::LinkManager::Link : new ::LinkManager::Link;
9916  }
9917  static void *newArray_LinkManagercLcLLink(Long_t nElements, void *p) {
9918  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::LinkManager::Link[nElements] : new ::LinkManager::Link[nElements];
9919  }
9920  // Wrapper around operator delete
9921  static void delete_LinkManagercLcLLink(void *p) {
9922  delete ((::LinkManager::Link*)p);
9923  }
9924  static void deleteArray_LinkManagercLcLLink(void *p) {
9925  delete [] ((::LinkManager::Link*)p);
9926  }
9927  static void destruct_LinkManagercLcLLink(void *p) {
9928  typedef ::LinkManager::Link current_t;
9929  ((current_t*)p)->~current_t();
9930  }
9931 } // end of namespace ROOT for class ::LinkManager::Link
9932 
9933 namespace ROOT {
9934  // Wrappers around operator new
9935  static void *new_SmartRefBase(void *p) {
9936  return p ? new(p) ::SmartRefBase : new ::SmartRefBase;
9937  }
9938  static void *newArray_SmartRefBase(Long_t nElements, void *p) {
9939  return p ? new(p) ::SmartRefBase[nElements] : new ::SmartRefBase[nElements];
9940  }
9941  // Wrapper around operator delete
9942  static void delete_SmartRefBase(void *p) {
9943  delete ((::SmartRefBase*)p);
9944  }
9945  static void deleteArray_SmartRefBase(void *p) {
9946  delete [] ((::SmartRefBase*)p);
9947  }
9948  static void destruct_SmartRefBase(void *p) {
9949  typedef ::SmartRefBase current_t;
9950  ((current_t*)p)->~current_t();
9951  }
9952 } // end of namespace ROOT for class ::SmartRefBase
9953 
9954 namespace ROOT {
9955  // Wrappers around operator new
9956  static void *new_SmartReflEDataObjectgR(void *p) {
9957  return p ? new(p) ::SmartRef<DataObject> : new ::SmartRef<DataObject>;
9958  }
9959  static void *newArray_SmartReflEDataObjectgR(Long_t nElements, void *p) {
9960  return p ? new(p) ::SmartRef<DataObject>[nElements] : new ::SmartRef<DataObject>[nElements];
9961  }
9962  // Wrapper around operator delete
9963  static void delete_SmartReflEDataObjectgR(void *p) {
9964  delete ((::SmartRef<DataObject>*)p);
9965  }
9966  static void deleteArray_SmartReflEDataObjectgR(void *p) {
9967  delete [] ((::SmartRef<DataObject>*)p);
9968  }
9969  static void destruct_SmartReflEDataObjectgR(void *p) {
9970  typedef ::SmartRef<DataObject> current_t;
9971  ((current_t*)p)->~current_t();
9972  }
9973 } // end of namespace ROOT for class ::SmartRef<DataObject>
9974 
9975 namespace ROOT {
9976  // Wrappers around operator new
9977  static void *new_SmartReflEContainedObjectgR(void *p) {
9978  return p ? new(p) ::SmartRef<ContainedObject> : new ::SmartRef<ContainedObject>;
9979  }
9980  static void *newArray_SmartReflEContainedObjectgR(Long_t nElements, void *p) {
9981  return p ? new(p) ::SmartRef<ContainedObject>[nElements] : new ::SmartRef<ContainedObject>[nElements];
9982  }
9983  // Wrapper around operator delete
9984  static void delete_SmartReflEContainedObjectgR(void *p) {
9985  delete ((::SmartRef<ContainedObject>*)p);
9986  }
9987  static void deleteArray_SmartReflEContainedObjectgR(void *p) {
9988  delete [] ((::SmartRef<ContainedObject>*)p);
9989  }
9990  static void destruct_SmartReflEContainedObjectgR(void *p) {
9991  typedef ::SmartRef<ContainedObject> current_t;
9992  ((current_t*)p)->~current_t();
9993  }
9994 } // end of namespace ROOT for class ::SmartRef<ContainedObject>
9995 
9996 namespace ROOT {
9997  // Wrappers around operator new
9998  static void *new_SmartReflEObjectContainerBasegR(void *p) {
9999  return p ? new(p) ::SmartRef<ObjectContainerBase> : new ::SmartRef<ObjectContainerBase>;
10000  }
10001  static void *newArray_SmartReflEObjectContainerBasegR(Long_t nElements, void *p) {
10002  return p ? new(p) ::SmartRef<ObjectContainerBase>[nElements] : new ::SmartRef<ObjectContainerBase>[nElements];
10003  }
10004  // Wrapper around operator delete
10005  static void delete_SmartReflEObjectContainerBasegR(void *p) {
10006  delete ((::SmartRef<ObjectContainerBase>*)p);
10007  }
10008  static void deleteArray_SmartReflEObjectContainerBasegR(void *p) {
10009  delete [] ((::SmartRef<ObjectContainerBase>*)p);
10010  }
10011  static void destruct_SmartReflEObjectContainerBasegR(void *p) {
10012  typedef ::SmartRef<ObjectContainerBase> current_t;
10013  ((current_t*)p)->~current_t();
10014  }
10015 } // end of namespace ROOT for class ::SmartRef<ObjectContainerBase>
10016 
10017 namespace ROOT {
10018  // Wrappers around operator new
10019  static void *new_SmartReflEKeyedObjectlEintgRsPgR(void *p) {
10020  return p ? new(p) ::SmartRef<KeyedObject<int> > : new ::SmartRef<KeyedObject<int> >;
10021  }
10022  static void *newArray_SmartReflEKeyedObjectlEintgRsPgR(Long_t nElements, void *p) {
10023  return p ? new(p) ::SmartRef<KeyedObject<int> >[nElements] : new ::SmartRef<KeyedObject<int> >[nElements];
10024  }
10025  // Wrapper around operator delete
10026  static void delete_SmartReflEKeyedObjectlEintgRsPgR(void *p) {
10027  delete ((::SmartRef<KeyedObject<int> >*)p);
10028  }
10029  static void deleteArray_SmartReflEKeyedObjectlEintgRsPgR(void *p) {
10030  delete [] ((::SmartRef<KeyedObject<int> >*)p);
10031  }
10032  static void destruct_SmartReflEKeyedObjectlEintgRsPgR(void *p) {
10033  typedef ::SmartRef<KeyedObject<int> > current_t;
10034  ((current_t*)p)->~current_t();
10035  }
10036 } // end of namespace ROOT for class ::SmartRef<KeyedObject<int> >
10037 
10038 namespace ROOT {
10039  // Wrappers around operator new
10040  static void *new_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
10041  return p ? new(p) ::SmartRef<KeyedObject<unsigned int> > : new ::SmartRef<KeyedObject<unsigned int> >;
10042  }
10043  static void *newArray_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(Long_t nElements, void *p) {
10044  return p ? new(p) ::SmartRef<KeyedObject<unsigned int> >[nElements] : new ::SmartRef<KeyedObject<unsigned int> >[nElements];
10045  }
10046  // Wrapper around operator delete
10047  static void delete_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
10048  delete ((::SmartRef<KeyedObject<unsigned int> >*)p);
10049  }
10050  static void deleteArray_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
10051  delete [] ((::SmartRef<KeyedObject<unsigned int> >*)p);
10052  }
10053  static void destruct_SmartReflEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
10054  typedef ::SmartRef<KeyedObject<unsigned int> > current_t;
10055  ((current_t*)p)->~current_t();
10056  }
10057 } // end of namespace ROOT for class ::SmartRef<KeyedObject<unsigned int> >
10058 
10059 namespace ROOT {
10060  // Wrappers around operator new
10061  static void *new_SmartReflEKeyedObjectlElonggRsPgR(void *p) {
10062  return p ? new(p) ::SmartRef<KeyedObject<long> > : new ::SmartRef<KeyedObject<long> >;
10063  }
10064  static void *newArray_SmartReflEKeyedObjectlElonggRsPgR(Long_t nElements, void *p) {
10065  return p ? new(p) ::SmartRef<KeyedObject<long> >[nElements] : new ::SmartRef<KeyedObject<long> >[nElements];
10066  }
10067  // Wrapper around operator delete
10068  static void delete_SmartReflEKeyedObjectlElonggRsPgR(void *p) {
10069  delete ((::SmartRef<KeyedObject<long> >*)p);
10070  }
10071  static void deleteArray_SmartReflEKeyedObjectlElonggRsPgR(void *p) {
10072  delete [] ((::SmartRef<KeyedObject<long> >*)p);
10073  }
10074  static void destruct_SmartReflEKeyedObjectlElonggRsPgR(void *p) {
10075  typedef ::SmartRef<KeyedObject<long> > current_t;
10076  ((current_t*)p)->~current_t();
10077  }
10078 } // end of namespace ROOT for class ::SmartRef<KeyedObject<long> >
10079 
10080 namespace ROOT {
10081  // Wrappers around operator new
10082  static void *new_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
10083  return p ? new(p) ::SmartRef<KeyedObject<unsigned long> > : new ::SmartRef<KeyedObject<unsigned long> >;
10084  }
10085  static void *newArray_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(Long_t nElements, void *p) {
10086  return p ? new(p) ::SmartRef<KeyedObject<unsigned long> >[nElements] : new ::SmartRef<KeyedObject<unsigned long> >[nElements];
10087  }
10088  // Wrapper around operator delete
10089  static void delete_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
10090  delete ((::SmartRef<KeyedObject<unsigned long> >*)p);
10091  }
10092  static void deleteArray_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
10093  delete [] ((::SmartRef<KeyedObject<unsigned long> >*)p);
10094  }
10095  static void destruct_SmartReflEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
10096  typedef ::SmartRef<KeyedObject<unsigned long> > current_t;
10097  ((current_t*)p)->~current_t();
10098  }
10099 } // end of namespace ROOT for class ::SmartRef<KeyedObject<unsigned long> >
10100 
10101 namespace ROOT {
10102  // Wrapper around operator delete
10103  static void delete_INTuple(void *p) {
10104  delete ((::INTuple*)p);
10105  }
10106  static void deleteArray_INTuple(void *p) {
10107  delete [] ((::INTuple*)p);
10108  }
10109  static void destruct_INTuple(void *p) {
10110  typedef ::INTuple current_t;
10111  ((current_t*)p)->~current_t();
10112  }
10113 } // end of namespace ROOT for class ::INTuple
10114 
10115 namespace ROOT {
10116  // Wrapper around operator delete
10117  static void delete_SmartDataObjectPtr(void *p) {
10118  delete ((::SmartDataObjectPtr*)p);
10119  }
10120  static void deleteArray_SmartDataObjectPtr(void *p) {
10121  delete [] ((::SmartDataObjectPtr*)p);
10122  }
10123  static void destruct_SmartDataObjectPtr(void *p) {
10124  typedef ::SmartDataObjectPtr current_t;
10125  ((current_t*)p)->~current_t();
10126  }
10127 } // end of namespace ROOT for class ::SmartDataObjectPtr
10128 
10129 namespace ROOT {
10130  // Wrappers around operator new
10131  static void *new_SmartDataObjectPtrcLcLObjectLoader(void *p) {
10132  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::SmartDataObjectPtr::ObjectLoader : new ::SmartDataObjectPtr::ObjectLoader;
10133  }
10134  static void *newArray_SmartDataObjectPtrcLcLObjectLoader(Long_t nElements, void *p) {
10135  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::SmartDataObjectPtr::ObjectLoader[nElements] : new ::SmartDataObjectPtr::ObjectLoader[nElements];
10136  }
10137  // Wrapper around operator delete
10138  static void delete_SmartDataObjectPtrcLcLObjectLoader(void *p) {
10139  delete ((::SmartDataObjectPtr::ObjectLoader*)p);
10140  }
10141  static void deleteArray_SmartDataObjectPtrcLcLObjectLoader(void *p) {
10142  delete [] ((::SmartDataObjectPtr::ObjectLoader*)p);
10143  }
10144  static void destruct_SmartDataObjectPtrcLcLObjectLoader(void *p) {
10145  typedef ::SmartDataObjectPtr::ObjectLoader current_t;
10146  ((current_t*)p)->~current_t();
10147  }
10148 } // end of namespace ROOT for class ::SmartDataObjectPtr::ObjectLoader
10149 
10150 namespace ROOT {
10151  // Wrappers around operator new
10152  static void *new_SmartDataObjectPtrcLcLObjectFinder(void *p) {
10153  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::SmartDataObjectPtr::ObjectFinder : new ::SmartDataObjectPtr::ObjectFinder;
10154  }
10155  static void *newArray_SmartDataObjectPtrcLcLObjectFinder(Long_t nElements, void *p) {
10156  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::SmartDataObjectPtr::ObjectFinder[nElements] : new ::SmartDataObjectPtr::ObjectFinder[nElements];
10157  }
10158  // Wrapper around operator delete
10159  static void delete_SmartDataObjectPtrcLcLObjectFinder(void *p) {
10160  delete ((::SmartDataObjectPtr::ObjectFinder*)p);
10161  }
10162  static void deleteArray_SmartDataObjectPtrcLcLObjectFinder(void *p) {
10163  delete [] ((::SmartDataObjectPtr::ObjectFinder*)p);
10164  }
10165  static void destruct_SmartDataObjectPtrcLcLObjectFinder(void *p) {
10166  typedef ::SmartDataObjectPtr::ObjectFinder current_t;
10167  ((current_t*)p)->~current_t();
10168  }
10169 } // end of namespace ROOT for class ::SmartDataObjectPtr::ObjectFinder
10170 
10171 namespace ROOT {
10172  // Wrapper around operator delete
10173  static void delete_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR(void *p) {
10174  delete ((::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)p);
10175  }
10176  static void deleteArray_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR(void *p) {
10177  delete [] ((::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>*)p);
10178  }
10179  static void destruct_SmartDataStorePtrlEDataObjectcOSmartDataObjectPtrcLcLObjectLoadergR(void *p) {
10180  typedef ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader> current_t;
10181  ((current_t*)p)->~current_t();
10182  }
10183 } // end of namespace ROOT for class ::SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>
10184 
10185 namespace ROOT {
10186  // Wrapper around operator delete
10187  static void delete_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR(void *p) {
10188  delete ((::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)p);
10189  }
10190  static void deleteArray_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR(void *p) {
10191  delete [] ((::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>*)p);
10192  }
10193  static void destruct_SmartDataStorePtrlEObjectContainerBasecOSmartDataObjectPtrcLcLObjectLoadergR(void *p) {
10194  typedef ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader> current_t;
10195  ((current_t*)p)->~current_t();
10196  }
10197 } // end of namespace ROOT for class ::SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>
10198 
10199 namespace ROOT {
10200  // Wrapper around operator delete
10201  static void delete_SmartDataPtrlEDataObjectgR(void *p) {
10202  delete ((::SmartDataPtr<DataObject>*)p);
10203  }
10204  static void deleteArray_SmartDataPtrlEDataObjectgR(void *p) {
10205  delete [] ((::SmartDataPtr<DataObject>*)p);
10206  }
10207  static void destruct_SmartDataPtrlEDataObjectgR(void *p) {
10208  typedef ::SmartDataPtr<DataObject> current_t;
10209  ((current_t*)p)->~current_t();
10210  }
10211 } // end of namespace ROOT for class ::SmartDataPtr<DataObject>
10212 
10213 namespace ROOT {
10214  // Wrapper around operator delete
10215  static void delete_SmartDataPtrlEObjectContainerBasegR(void *p) {
10216  delete ((::SmartDataPtr<ObjectContainerBase>*)p);
10217  }
10218  static void deleteArray_SmartDataPtrlEObjectContainerBasegR(void *p) {
10219  delete [] ((::SmartDataPtr<ObjectContainerBase>*)p);
10220  }
10221  static void destruct_SmartDataPtrlEObjectContainerBasegR(void *p) {
10222  typedef ::SmartDataPtr<ObjectContainerBase> current_t;
10223  ((current_t*)p)->~current_t();
10224  }
10225 } // end of namespace ROOT for class ::SmartDataPtr<ObjectContainerBase>
10226 
10227 namespace ROOT {
10228  // Wrappers around operator new
10229  static void *new_NTuplecLcLItemlEchargR(void *p) {
10230  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<char> : new ::NTuple::Item<char>;
10231  }
10232  static void *newArray_NTuplecLcLItemlEchargR(Long_t nElements, void *p) {
10233  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<char>[nElements] : new ::NTuple::Item<char>[nElements];
10234  }
10235  // Wrapper around operator delete
10236  static void delete_NTuplecLcLItemlEchargR(void *p) {
10237  delete ((::NTuple::Item<char>*)p);
10238  }
10239  static void deleteArray_NTuplecLcLItemlEchargR(void *p) {
10240  delete [] ((::NTuple::Item<char>*)p);
10241  }
10242  static void destruct_NTuplecLcLItemlEchargR(void *p) {
10243  typedef ::NTuple::Item<char> current_t;
10244  ((current_t*)p)->~current_t();
10245  }
10246 } // end of namespace ROOT for class ::NTuple::Item<char>
10247 
10248 namespace ROOT {
10249  // Wrappers around operator new
10250  static void *new_NTuplecLcLItemlEunsignedsPchargR(void *p) {
10251  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned char> : new ::NTuple::Item<unsigned char>;
10252  }
10253  static void *newArray_NTuplecLcLItemlEunsignedsPchargR(Long_t nElements, void *p) {
10254  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned char>[nElements] : new ::NTuple::Item<unsigned char>[nElements];
10255  }
10256  // Wrapper around operator delete
10257  static void delete_NTuplecLcLItemlEunsignedsPchargR(void *p) {
10258  delete ((::NTuple::Item<unsigned char>*)p);
10259  }
10260  static void deleteArray_NTuplecLcLItemlEunsignedsPchargR(void *p) {
10261  delete [] ((::NTuple::Item<unsigned char>*)p);
10262  }
10263  static void destruct_NTuplecLcLItemlEunsignedsPchargR(void *p) {
10264  typedef ::NTuple::Item<unsigned char> current_t;
10265  ((current_t*)p)->~current_t();
10266  }
10267 } // end of namespace ROOT for class ::NTuple::Item<unsigned char>
10268 
10269 namespace ROOT {
10270  // Wrappers around operator new
10271  static void *new_NTuplecLcLItemlEshortgR(void *p) {
10272  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<short> : new ::NTuple::Item<short>;
10273  }
10274  static void *newArray_NTuplecLcLItemlEshortgR(Long_t nElements, void *p) {
10275  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<short>[nElements] : new ::NTuple::Item<short>[nElements];
10276  }
10277  // Wrapper around operator delete
10278  static void delete_NTuplecLcLItemlEshortgR(void *p) {
10279  delete ((::NTuple::Item<short>*)p);
10280  }
10281  static void deleteArray_NTuplecLcLItemlEshortgR(void *p) {
10282  delete [] ((::NTuple::Item<short>*)p);
10283  }
10284  static void destruct_NTuplecLcLItemlEshortgR(void *p) {
10285  typedef ::NTuple::Item<short> current_t;
10286  ((current_t*)p)->~current_t();
10287  }
10288 } // end of namespace ROOT for class ::NTuple::Item<short>
10289 
10290 namespace ROOT {
10291  // Wrappers around operator new
10292  static void *new_NTuplecLcLItemlEunsignedsPshortgR(void *p) {
10293  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned short> : new ::NTuple::Item<unsigned short>;
10294  }
10295  static void *newArray_NTuplecLcLItemlEunsignedsPshortgR(Long_t nElements, void *p) {
10296  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned short>[nElements] : new ::NTuple::Item<unsigned short>[nElements];
10297  }
10298  // Wrapper around operator delete
10299  static void delete_NTuplecLcLItemlEunsignedsPshortgR(void *p) {
10300  delete ((::NTuple::Item<unsigned short>*)p);
10301  }
10302  static void deleteArray_NTuplecLcLItemlEunsignedsPshortgR(void *p) {
10303  delete [] ((::NTuple::Item<unsigned short>*)p);
10304  }
10305  static void destruct_NTuplecLcLItemlEunsignedsPshortgR(void *p) {
10306  typedef ::NTuple::Item<unsigned short> current_t;
10307  ((current_t*)p)->~current_t();
10308  }
10309 } // end of namespace ROOT for class ::NTuple::Item<unsigned short>
10310 
10311 namespace ROOT {
10312  // Wrappers around operator new
10313  static void *new_NTuplecLcLItemlElonggR(void *p) {
10314  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<long> : new ::NTuple::Item<long>;
10315  }
10316  static void *newArray_NTuplecLcLItemlElonggR(Long_t nElements, void *p) {
10317  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<long>[nElements] : new ::NTuple::Item<long>[nElements];
10318  }
10319  // Wrapper around operator delete
10320  static void delete_NTuplecLcLItemlElonggR(void *p) {
10321  delete ((::NTuple::Item<long>*)p);
10322  }
10323  static void deleteArray_NTuplecLcLItemlElonggR(void *p) {
10324  delete [] ((::NTuple::Item<long>*)p);
10325  }
10326  static void destruct_NTuplecLcLItemlElonggR(void *p) {
10327  typedef ::NTuple::Item<long> current_t;
10328  ((current_t*)p)->~current_t();
10329  }
10330 } // end of namespace ROOT for class ::NTuple::Item<long>
10331 
10332 namespace ROOT {
10333  // Wrappers around operator new
10334  static void *new_NTuplecLcLItemlELong64_tgR(void *p) {
10335  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<Long64_t> : new ::NTuple::Item<Long64_t>;
10336  }
10337  static void *newArray_NTuplecLcLItemlELong64_tgR(Long_t nElements, void *p) {
10338  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<Long64_t>[nElements] : new ::NTuple::Item<Long64_t>[nElements];
10339  }
10340  // Wrapper around operator delete
10341  static void delete_NTuplecLcLItemlELong64_tgR(void *p) {
10342  delete ((::NTuple::Item<Long64_t>*)p);
10343  }
10344  static void deleteArray_NTuplecLcLItemlELong64_tgR(void *p) {
10345  delete [] ((::NTuple::Item<Long64_t>*)p);
10346  }
10347  static void destruct_NTuplecLcLItemlELong64_tgR(void *p) {
10348  typedef ::NTuple::Item<Long64_t> current_t;
10349  ((current_t*)p)->~current_t();
10350  }
10351 } // end of namespace ROOT for class ::NTuple::Item<Long64_t>
10352 
10353 namespace ROOT {
10354  // Wrappers around operator new
10355  static void *new_NTuplecLcLItemlEunsignedsPlonggR(void *p) {
10356  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned long> : new ::NTuple::Item<unsigned long>;
10357  }
10358  static void *newArray_NTuplecLcLItemlEunsignedsPlonggR(Long_t nElements, void *p) {
10359  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned long>[nElements] : new ::NTuple::Item<unsigned long>[nElements];
10360  }
10361  // Wrapper around operator delete
10362  static void delete_NTuplecLcLItemlEunsignedsPlonggR(void *p) {
10363  delete ((::NTuple::Item<unsigned long>*)p);
10364  }
10365  static void deleteArray_NTuplecLcLItemlEunsignedsPlonggR(void *p) {
10366  delete [] ((::NTuple::Item<unsigned long>*)p);
10367  }
10368  static void destruct_NTuplecLcLItemlEunsignedsPlonggR(void *p) {
10369  typedef ::NTuple::Item<unsigned long> current_t;
10370  ((current_t*)p)->~current_t();
10371  }
10372 } // end of namespace ROOT for class ::NTuple::Item<unsigned long>
10373 
10374 namespace ROOT {
10375  // Wrappers around operator new
10376  static void *new_NTuplecLcLItemlEULong64_tgR(void *p) {
10377  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<ULong64_t> : new ::NTuple::Item<ULong64_t>;
10378  }
10379  static void *newArray_NTuplecLcLItemlEULong64_tgR(Long_t nElements, void *p) {
10380  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<ULong64_t>[nElements] : new ::NTuple::Item<ULong64_t>[nElements];
10381  }
10382  // Wrapper around operator delete
10383  static void delete_NTuplecLcLItemlEULong64_tgR(void *p) {
10384  delete ((::NTuple::Item<ULong64_t>*)p);
10385  }
10386  static void deleteArray_NTuplecLcLItemlEULong64_tgR(void *p) {
10387  delete [] ((::NTuple::Item<ULong64_t>*)p);
10388  }
10389  static void destruct_NTuplecLcLItemlEULong64_tgR(void *p) {
10390  typedef ::NTuple::Item<ULong64_t> current_t;
10391  ((current_t*)p)->~current_t();
10392  }
10393 } // end of namespace ROOT for class ::NTuple::Item<ULong64_t>
10394 
10395 namespace ROOT {
10396  // Wrappers around operator new
10397  static void *new_NTuplecLcLItemlEintgR(void *p) {
10398  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<int> : new ::NTuple::Item<int>;
10399  }
10400  static void *newArray_NTuplecLcLItemlEintgR(Long_t nElements, void *p) {
10401  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<int>[nElements] : new ::NTuple::Item<int>[nElements];
10402  }
10403  // Wrapper around operator delete
10404  static void delete_NTuplecLcLItemlEintgR(void *p) {
10405  delete ((::NTuple::Item<int>*)p);
10406  }
10407  static void deleteArray_NTuplecLcLItemlEintgR(void *p) {
10408  delete [] ((::NTuple::Item<int>*)p);
10409  }
10410  static void destruct_NTuplecLcLItemlEintgR(void *p) {
10411  typedef ::NTuple::Item<int> current_t;
10412  ((current_t*)p)->~current_t();
10413  }
10414 } // end of namespace ROOT for class ::NTuple::Item<int>
10415 
10416 namespace ROOT {
10417  // Wrappers around operator new
10418  static void *new_NTuplecLcLItemlEunsignedsPintgR(void *p) {
10419  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned int> : new ::NTuple::Item<unsigned int>;
10420  }
10421  static void *newArray_NTuplecLcLItemlEunsignedsPintgR(Long_t nElements, void *p) {
10422  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<unsigned int>[nElements] : new ::NTuple::Item<unsigned int>[nElements];
10423  }
10424  // Wrapper around operator delete
10425  static void delete_NTuplecLcLItemlEunsignedsPintgR(void *p) {
10426  delete ((::NTuple::Item<unsigned int>*)p);
10427  }
10428  static void deleteArray_NTuplecLcLItemlEunsignedsPintgR(void *p) {
10429  delete [] ((::NTuple::Item<unsigned int>*)p);
10430  }
10431  static void destruct_NTuplecLcLItemlEunsignedsPintgR(void *p) {
10432  typedef ::NTuple::Item<unsigned int> current_t;
10433  ((current_t*)p)->~current_t();
10434  }
10435 } // end of namespace ROOT for class ::NTuple::Item<unsigned int>
10436 
10437 namespace ROOT {
10438  // Wrappers around operator new
10439  static void *new_NTuplecLcLItemlEfloatgR(void *p) {
10440  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<float> : new ::NTuple::Item<float>;
10441  }
10442  static void *newArray_NTuplecLcLItemlEfloatgR(Long_t nElements, void *p) {
10443  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<float>[nElements] : new ::NTuple::Item<float>[nElements];
10444  }
10445  // Wrapper around operator delete
10446  static void delete_NTuplecLcLItemlEfloatgR(void *p) {
10447  delete ((::NTuple::Item<float>*)p);
10448  }
10449  static void deleteArray_NTuplecLcLItemlEfloatgR(void *p) {
10450  delete [] ((::NTuple::Item<float>*)p);
10451  }
10452  static void destruct_NTuplecLcLItemlEfloatgR(void *p) {
10453  typedef ::NTuple::Item<float> current_t;
10454  ((current_t*)p)->~current_t();
10455  }
10456 } // end of namespace ROOT for class ::NTuple::Item<float>
10457 
10458 namespace ROOT {
10459  // Wrappers around operator new
10460  static void *new_NTuplecLcLItemlEdoublegR(void *p) {
10461  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<double> : new ::NTuple::Item<double>;
10462  }
10463  static void *newArray_NTuplecLcLItemlEdoublegR(Long_t nElements, void *p) {
10464  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<double>[nElements] : new ::NTuple::Item<double>[nElements];
10465  }
10466  // Wrapper around operator delete
10467  static void delete_NTuplecLcLItemlEdoublegR(void *p) {
10468  delete ((::NTuple::Item<double>*)p);
10469  }
10470  static void deleteArray_NTuplecLcLItemlEdoublegR(void *p) {
10471  delete [] ((::NTuple::Item<double>*)p);
10472  }
10473  static void destruct_NTuplecLcLItemlEdoublegR(void *p) {
10474  typedef ::NTuple::Item<double> current_t;
10475  ((current_t*)p)->~current_t();
10476  }
10477 } // end of namespace ROOT for class ::NTuple::Item<double>
10478 
10479 namespace ROOT {
10480  // Wrappers around operator new
10481  static void *new_NTuplecLcLArraylEboolgR(void *p) {
10482  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<bool> : new ::NTuple::Array<bool>;
10483  }
10484  static void *newArray_NTuplecLcLArraylEboolgR(Long_t nElements, void *p) {
10485  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<bool>[nElements] : new ::NTuple::Array<bool>[nElements];
10486  }
10487  // Wrapper around operator delete
10488  static void delete_NTuplecLcLArraylEboolgR(void *p) {
10489  delete ((::NTuple::Array<bool>*)p);
10490  }
10491  static void deleteArray_NTuplecLcLArraylEboolgR(void *p) {
10492  delete [] ((::NTuple::Array<bool>*)p);
10493  }
10494  static void destruct_NTuplecLcLArraylEboolgR(void *p) {
10495  typedef ::NTuple::Array<bool> current_t;
10496  ((current_t*)p)->~current_t();
10497  }
10498 } // end of namespace ROOT for class ::NTuple::Array<bool>
10499 
10500 namespace ROOT {
10501  // Wrappers around operator new
10502  static void *new_NTuplecLcLArraylEchargR(void *p) {
10503  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<char> : new ::NTuple::Array<char>;
10504  }
10505  static void *newArray_NTuplecLcLArraylEchargR(Long_t nElements, void *p) {
10506  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<char>[nElements] : new ::NTuple::Array<char>[nElements];
10507  }
10508  // Wrapper around operator delete
10509  static void delete_NTuplecLcLArraylEchargR(void *p) {
10510  delete ((::NTuple::Array<char>*)p);
10511  }
10512  static void deleteArray_NTuplecLcLArraylEchargR(void *p) {
10513  delete [] ((::NTuple::Array<char>*)p);
10514  }
10515  static void destruct_NTuplecLcLArraylEchargR(void *p) {
10516  typedef ::NTuple::Array<char> current_t;
10517  ((current_t*)p)->~current_t();
10518  }
10519 } // end of namespace ROOT for class ::NTuple::Array<char>
10520 
10521 namespace ROOT {
10522  // Wrappers around operator new
10523  static void *new_NTuplecLcLArraylEunsignedsPchargR(void *p) {
10524  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned char> : new ::NTuple::Array<unsigned char>;
10525  }
10526  static void *newArray_NTuplecLcLArraylEunsignedsPchargR(Long_t nElements, void *p) {
10527  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned char>[nElements] : new ::NTuple::Array<unsigned char>[nElements];
10528  }
10529  // Wrapper around operator delete
10530  static void delete_NTuplecLcLArraylEunsignedsPchargR(void *p) {
10531  delete ((::NTuple::Array<unsigned char>*)p);
10532  }
10533  static void deleteArray_NTuplecLcLArraylEunsignedsPchargR(void *p) {
10534  delete [] ((::NTuple::Array<unsigned char>*)p);
10535  }
10536  static void destruct_NTuplecLcLArraylEunsignedsPchargR(void *p) {
10537  typedef ::NTuple::Array<unsigned char> current_t;
10538  ((current_t*)p)->~current_t();
10539  }
10540 } // end of namespace ROOT for class ::NTuple::Array<unsigned char>
10541 
10542 namespace ROOT {
10543  // Wrappers around operator new
10544  static void *new_NTuplecLcLArraylEshortgR(void *p) {
10545  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<short> : new ::NTuple::Array<short>;
10546  }
10547  static void *newArray_NTuplecLcLArraylEshortgR(Long_t nElements, void *p) {
10548  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<short>[nElements] : new ::NTuple::Array<short>[nElements];
10549  }
10550  // Wrapper around operator delete
10551  static void delete_NTuplecLcLArraylEshortgR(void *p) {
10552  delete ((::NTuple::Array<short>*)p);
10553  }
10554  static void deleteArray_NTuplecLcLArraylEshortgR(void *p) {
10555  delete [] ((::NTuple::Array<short>*)p);
10556  }
10557  static void destruct_NTuplecLcLArraylEshortgR(void *p) {
10558  typedef ::NTuple::Array<short> current_t;
10559  ((current_t*)p)->~current_t();
10560  }
10561 } // end of namespace ROOT for class ::NTuple::Array<short>
10562 
10563 namespace ROOT {
10564  // Wrappers around operator new
10565  static void *new_NTuplecLcLArraylEunsignedsPshortgR(void *p) {
10566  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned short> : new ::NTuple::Array<unsigned short>;
10567  }
10568  static void *newArray_NTuplecLcLArraylEunsignedsPshortgR(Long_t nElements, void *p) {
10569  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned short>[nElements] : new ::NTuple::Array<unsigned short>[nElements];
10570  }
10571  // Wrapper around operator delete
10572  static void delete_NTuplecLcLArraylEunsignedsPshortgR(void *p) {
10573  delete ((::NTuple::Array<unsigned short>*)p);
10574  }
10575  static void deleteArray_NTuplecLcLArraylEunsignedsPshortgR(void *p) {
10576  delete [] ((::NTuple::Array<unsigned short>*)p);
10577  }
10578  static void destruct_NTuplecLcLArraylEunsignedsPshortgR(void *p) {
10579  typedef ::NTuple::Array<unsigned short> current_t;
10580  ((current_t*)p)->~current_t();
10581  }
10582 } // end of namespace ROOT for class ::NTuple::Array<unsigned short>
10583 
10584 namespace ROOT {
10585  // Wrappers around operator new
10586  static void *new_NTuplecLcLArraylElonggR(void *p) {
10587  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<long> : new ::NTuple::Array<long>;
10588  }
10589  static void *newArray_NTuplecLcLArraylElonggR(Long_t nElements, void *p) {
10590  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<long>[nElements] : new ::NTuple::Array<long>[nElements];
10591  }
10592  // Wrapper around operator delete
10593  static void delete_NTuplecLcLArraylElonggR(void *p) {
10594  delete ((::NTuple::Array<long>*)p);
10595  }
10596  static void deleteArray_NTuplecLcLArraylElonggR(void *p) {
10597  delete [] ((::NTuple::Array<long>*)p);
10598  }
10599  static void destruct_NTuplecLcLArraylElonggR(void *p) {
10600  typedef ::NTuple::Array<long> current_t;
10601  ((current_t*)p)->~current_t();
10602  }
10603 } // end of namespace ROOT for class ::NTuple::Array<long>
10604 
10605 namespace ROOT {
10606  // Wrappers around operator new
10607  static void *new_NTuplecLcLArraylEunsignedsPlonggR(void *p) {
10608  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned long> : new ::NTuple::Array<unsigned long>;
10609  }
10610  static void *newArray_NTuplecLcLArraylEunsignedsPlonggR(Long_t nElements, void *p) {
10611  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned long>[nElements] : new ::NTuple::Array<unsigned long>[nElements];
10612  }
10613  // Wrapper around operator delete
10614  static void delete_NTuplecLcLArraylEunsignedsPlonggR(void *p) {
10615  delete ((::NTuple::Array<unsigned long>*)p);
10616  }
10617  static void deleteArray_NTuplecLcLArraylEunsignedsPlonggR(void *p) {
10618  delete [] ((::NTuple::Array<unsigned long>*)p);
10619  }
10620  static void destruct_NTuplecLcLArraylEunsignedsPlonggR(void *p) {
10621  typedef ::NTuple::Array<unsigned long> current_t;
10622  ((current_t*)p)->~current_t();
10623  }
10624 } // end of namespace ROOT for class ::NTuple::Array<unsigned long>
10625 
10626 namespace ROOT {
10627  // Wrappers around operator new
10628  static void *new_NTuplecLcLArraylEintgR(void *p) {
10629  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<int> : new ::NTuple::Array<int>;
10630  }
10631  static void *newArray_NTuplecLcLArraylEintgR(Long_t nElements, void *p) {
10632  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<int>[nElements] : new ::NTuple::Array<int>[nElements];
10633  }
10634  // Wrapper around operator delete
10635  static void delete_NTuplecLcLArraylEintgR(void *p) {
10636  delete ((::NTuple::Array<int>*)p);
10637  }
10638  static void deleteArray_NTuplecLcLArraylEintgR(void *p) {
10639  delete [] ((::NTuple::Array<int>*)p);
10640  }
10641  static void destruct_NTuplecLcLArraylEintgR(void *p) {
10642  typedef ::NTuple::Array<int> current_t;
10643  ((current_t*)p)->~current_t();
10644  }
10645 } // end of namespace ROOT for class ::NTuple::Array<int>
10646 
10647 namespace ROOT {
10648  // Wrappers around operator new
10649  static void *new_NTuplecLcLArraylEunsignedsPintgR(void *p) {
10650  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned int> : new ::NTuple::Array<unsigned int>;
10651  }
10652  static void *newArray_NTuplecLcLArraylEunsignedsPintgR(Long_t nElements, void *p) {
10653  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<unsigned int>[nElements] : new ::NTuple::Array<unsigned int>[nElements];
10654  }
10655  // Wrapper around operator delete
10656  static void delete_NTuplecLcLArraylEunsignedsPintgR(void *p) {
10657  delete ((::NTuple::Array<unsigned int>*)p);
10658  }
10659  static void deleteArray_NTuplecLcLArraylEunsignedsPintgR(void *p) {
10660  delete [] ((::NTuple::Array<unsigned int>*)p);
10661  }
10662  static void destruct_NTuplecLcLArraylEunsignedsPintgR(void *p) {
10663  typedef ::NTuple::Array<unsigned int> current_t;
10664  ((current_t*)p)->~current_t();
10665  }
10666 } // end of namespace ROOT for class ::NTuple::Array<unsigned int>
10667 
10668 namespace ROOT {
10669  // Wrappers around operator new
10670  static void *new_NTuplecLcLArraylEfloatgR(void *p) {
10671  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<float> : new ::NTuple::Array<float>;
10672  }
10673  static void *newArray_NTuplecLcLArraylEfloatgR(Long_t nElements, void *p) {
10674  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<float>[nElements] : new ::NTuple::Array<float>[nElements];
10675  }
10676  // Wrapper around operator delete
10677  static void delete_NTuplecLcLArraylEfloatgR(void *p) {
10678  delete ((::NTuple::Array<float>*)p);
10679  }
10680  static void deleteArray_NTuplecLcLArraylEfloatgR(void *p) {
10681  delete [] ((::NTuple::Array<float>*)p);
10682  }
10683  static void destruct_NTuplecLcLArraylEfloatgR(void *p) {
10684  typedef ::NTuple::Array<float> current_t;
10685  ((current_t*)p)->~current_t();
10686  }
10687 } // end of namespace ROOT for class ::NTuple::Array<float>
10688 
10689 namespace ROOT {
10690  // Wrappers around operator new
10691  static void *new_NTuplecLcLArraylEdoublegR(void *p) {
10692  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<double> : new ::NTuple::Array<double>;
10693  }
10694  static void *newArray_NTuplecLcLArraylEdoublegR(Long_t nElements, void *p) {
10695  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Array<double>[nElements] : new ::NTuple::Array<double>[nElements];
10696  }
10697  // Wrapper around operator delete
10698  static void delete_NTuplecLcLArraylEdoublegR(void *p) {
10699  delete ((::NTuple::Array<double>*)p);
10700  }
10701  static void deleteArray_NTuplecLcLArraylEdoublegR(void *p) {
10702  delete [] ((::NTuple::Array<double>*)p);
10703  }
10704  static void destruct_NTuplecLcLArraylEdoublegR(void *p) {
10705  typedef ::NTuple::Array<double> current_t;
10706  ((current_t*)p)->~current_t();
10707  }
10708 } // end of namespace ROOT for class ::NTuple::Array<double>
10709 
10710 namespace ROOT {
10711  // Wrappers around operator new
10712  static void *new_NTuplecLcLMatrixlEboolgR(void *p) {
10713  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<bool> : new ::NTuple::Matrix<bool>;
10714  }
10715  static void *newArray_NTuplecLcLMatrixlEboolgR(Long_t nElements, void *p) {
10716  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<bool>[nElements] : new ::NTuple::Matrix<bool>[nElements];
10717  }
10718  // Wrapper around operator delete
10719  static void delete_NTuplecLcLMatrixlEboolgR(void *p) {
10720  delete ((::NTuple::Matrix<bool>*)p);
10721  }
10722  static void deleteArray_NTuplecLcLMatrixlEboolgR(void *p) {
10723  delete [] ((::NTuple::Matrix<bool>*)p);
10724  }
10725  static void destruct_NTuplecLcLMatrixlEboolgR(void *p) {
10726  typedef ::NTuple::Matrix<bool> current_t;
10727  ((current_t*)p)->~current_t();
10728  }
10729 } // end of namespace ROOT for class ::NTuple::Matrix<bool>
10730 
10731 namespace ROOT {
10732  // Wrappers around operator new
10733  static void *new_NTuplecLcLMatrixlEchargR(void *p) {
10734  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<char> : new ::NTuple::Matrix<char>;
10735  }
10736  static void *newArray_NTuplecLcLMatrixlEchargR(Long_t nElements, void *p) {
10737  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<char>[nElements] : new ::NTuple::Matrix<char>[nElements];
10738  }
10739  // Wrapper around operator delete
10740  static void delete_NTuplecLcLMatrixlEchargR(void *p) {
10741  delete ((::NTuple::Matrix<char>*)p);
10742  }
10743  static void deleteArray_NTuplecLcLMatrixlEchargR(void *p) {
10744  delete [] ((::NTuple::Matrix<char>*)p);
10745  }
10746  static void destruct_NTuplecLcLMatrixlEchargR(void *p) {
10747  typedef ::NTuple::Matrix<char> current_t;
10748  ((current_t*)p)->~current_t();
10749  }
10750 } // end of namespace ROOT for class ::NTuple::Matrix<char>
10751 
10752 namespace ROOT {
10753  // Wrappers around operator new
10754  static void *new_NTuplecLcLMatrixlEunsignedsPchargR(void *p) {
10755  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned char> : new ::NTuple::Matrix<unsigned char>;
10756  }
10757  static void *newArray_NTuplecLcLMatrixlEunsignedsPchargR(Long_t nElements, void *p) {
10758  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned char>[nElements] : new ::NTuple::Matrix<unsigned char>[nElements];
10759  }
10760  // Wrapper around operator delete
10761  static void delete_NTuplecLcLMatrixlEunsignedsPchargR(void *p) {
10762  delete ((::NTuple::Matrix<unsigned char>*)p);
10763  }
10764  static void deleteArray_NTuplecLcLMatrixlEunsignedsPchargR(void *p) {
10765  delete [] ((::NTuple::Matrix<unsigned char>*)p);
10766  }
10767  static void destruct_NTuplecLcLMatrixlEunsignedsPchargR(void *p) {
10768  typedef ::NTuple::Matrix<unsigned char> current_t;
10769  ((current_t*)p)->~current_t();
10770  }
10771 } // end of namespace ROOT for class ::NTuple::Matrix<unsigned char>
10772 
10773 namespace ROOT {
10774  // Wrappers around operator new
10775  static void *new_NTuplecLcLMatrixlEshortgR(void *p) {
10776  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<short> : new ::NTuple::Matrix<short>;
10777  }
10778  static void *newArray_NTuplecLcLMatrixlEshortgR(Long_t nElements, void *p) {
10779  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<short>[nElements] : new ::NTuple::Matrix<short>[nElements];
10780  }
10781  // Wrapper around operator delete
10782  static void delete_NTuplecLcLMatrixlEshortgR(void *p) {
10783  delete ((::NTuple::Matrix<short>*)p);
10784  }
10785  static void deleteArray_NTuplecLcLMatrixlEshortgR(void *p) {
10786  delete [] ((::NTuple::Matrix<short>*)p);
10787  }
10788  static void destruct_NTuplecLcLMatrixlEshortgR(void *p) {
10789  typedef ::NTuple::Matrix<short> current_t;
10790  ((current_t*)p)->~current_t();
10791  }
10792 } // end of namespace ROOT for class ::NTuple::Matrix<short>
10793 
10794 namespace ROOT {
10795  // Wrappers around operator new
10796  static void *new_NTuplecLcLMatrixlEunsignedsPshortgR(void *p) {
10797  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned short> : new ::NTuple::Matrix<unsigned short>;
10798  }
10799  static void *newArray_NTuplecLcLMatrixlEunsignedsPshortgR(Long_t nElements, void *p) {
10800  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned short>[nElements] : new ::NTuple::Matrix<unsigned short>[nElements];
10801  }
10802  // Wrapper around operator delete
10803  static void delete_NTuplecLcLMatrixlEunsignedsPshortgR(void *p) {
10804  delete ((::NTuple::Matrix<unsigned short>*)p);
10805  }
10806  static void deleteArray_NTuplecLcLMatrixlEunsignedsPshortgR(void *p) {
10807  delete [] ((::NTuple::Matrix<unsigned short>*)p);
10808  }
10809  static void destruct_NTuplecLcLMatrixlEunsignedsPshortgR(void *p) {
10810  typedef ::NTuple::Matrix<unsigned short> current_t;
10811  ((current_t*)p)->~current_t();
10812  }
10813 } // end of namespace ROOT for class ::NTuple::Matrix<unsigned short>
10814 
10815 namespace ROOT {
10816  // Wrappers around operator new
10817  static void *new_NTuplecLcLMatrixlElonggR(void *p) {
10818  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<long> : new ::NTuple::Matrix<long>;
10819  }
10820  static void *newArray_NTuplecLcLMatrixlElonggR(Long_t nElements, void *p) {
10821  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<long>[nElements] : new ::NTuple::Matrix<long>[nElements];
10822  }
10823  // Wrapper around operator delete
10824  static void delete_NTuplecLcLMatrixlElonggR(void *p) {
10825  delete ((::NTuple::Matrix<long>*)p);
10826  }
10827  static void deleteArray_NTuplecLcLMatrixlElonggR(void *p) {
10828  delete [] ((::NTuple::Matrix<long>*)p);
10829  }
10830  static void destruct_NTuplecLcLMatrixlElonggR(void *p) {
10831  typedef ::NTuple::Matrix<long> current_t;
10832  ((current_t*)p)->~current_t();
10833  }
10834 } // end of namespace ROOT for class ::NTuple::Matrix<long>
10835 
10836 namespace ROOT {
10837  // Wrappers around operator new
10838  static void *new_NTuplecLcLMatrixlEunsignedsPlonggR(void *p) {
10839  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned long> : new ::NTuple::Matrix<unsigned long>;
10840  }
10841  static void *newArray_NTuplecLcLMatrixlEunsignedsPlonggR(Long_t nElements, void *p) {
10842  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned long>[nElements] : new ::NTuple::Matrix<unsigned long>[nElements];
10843  }
10844  // Wrapper around operator delete
10845  static void delete_NTuplecLcLMatrixlEunsignedsPlonggR(void *p) {
10846  delete ((::NTuple::Matrix<unsigned long>*)p);
10847  }
10848  static void deleteArray_NTuplecLcLMatrixlEunsignedsPlonggR(void *p) {
10849  delete [] ((::NTuple::Matrix<unsigned long>*)p);
10850  }
10851  static void destruct_NTuplecLcLMatrixlEunsignedsPlonggR(void *p) {
10852  typedef ::NTuple::Matrix<unsigned long> current_t;
10853  ((current_t*)p)->~current_t();
10854  }
10855 } // end of namespace ROOT for class ::NTuple::Matrix<unsigned long>
10856 
10857 namespace ROOT {
10858  // Wrappers around operator new
10859  static void *new_NTuplecLcLMatrixlEintgR(void *p) {
10860  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<int> : new ::NTuple::Matrix<int>;
10861  }
10862  static void *newArray_NTuplecLcLMatrixlEintgR(Long_t nElements, void *p) {
10863  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<int>[nElements] : new ::NTuple::Matrix<int>[nElements];
10864  }
10865  // Wrapper around operator delete
10866  static void delete_NTuplecLcLMatrixlEintgR(void *p) {
10867  delete ((::NTuple::Matrix<int>*)p);
10868  }
10869  static void deleteArray_NTuplecLcLMatrixlEintgR(void *p) {
10870  delete [] ((::NTuple::Matrix<int>*)p);
10871  }
10872  static void destruct_NTuplecLcLMatrixlEintgR(void *p) {
10873  typedef ::NTuple::Matrix<int> current_t;
10874  ((current_t*)p)->~current_t();
10875  }
10876 } // end of namespace ROOT for class ::NTuple::Matrix<int>
10877 
10878 namespace ROOT {
10879  // Wrappers around operator new
10880  static void *new_NTuplecLcLMatrixlEunsignedsPintgR(void *p) {
10881  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned int> : new ::NTuple::Matrix<unsigned int>;
10882  }
10883  static void *newArray_NTuplecLcLMatrixlEunsignedsPintgR(Long_t nElements, void *p) {
10884  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<unsigned int>[nElements] : new ::NTuple::Matrix<unsigned int>[nElements];
10885  }
10886  // Wrapper around operator delete
10887  static void delete_NTuplecLcLMatrixlEunsignedsPintgR(void *p) {
10888  delete ((::NTuple::Matrix<unsigned int>*)p);
10889  }
10890  static void deleteArray_NTuplecLcLMatrixlEunsignedsPintgR(void *p) {
10891  delete [] ((::NTuple::Matrix<unsigned int>*)p);
10892  }
10893  static void destruct_NTuplecLcLMatrixlEunsignedsPintgR(void *p) {
10894  typedef ::NTuple::Matrix<unsigned int> current_t;
10895  ((current_t*)p)->~current_t();
10896  }
10897 } // end of namespace ROOT for class ::NTuple::Matrix<unsigned int>
10898 
10899 namespace ROOT {
10900  // Wrappers around operator new
10901  static void *new_NTuplecLcLMatrixlEfloatgR(void *p) {
10902  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<float> : new ::NTuple::Matrix<float>;
10903  }
10904  static void *newArray_NTuplecLcLMatrixlEfloatgR(Long_t nElements, void *p) {
10905  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<float>[nElements] : new ::NTuple::Matrix<float>[nElements];
10906  }
10907  // Wrapper around operator delete
10908  static void delete_NTuplecLcLMatrixlEfloatgR(void *p) {
10909  delete ((::NTuple::Matrix<float>*)p);
10910  }
10911  static void deleteArray_NTuplecLcLMatrixlEfloatgR(void *p) {
10912  delete [] ((::NTuple::Matrix<float>*)p);
10913  }
10914  static void destruct_NTuplecLcLMatrixlEfloatgR(void *p) {
10915  typedef ::NTuple::Matrix<float> current_t;
10916  ((current_t*)p)->~current_t();
10917  }
10918 } // end of namespace ROOT for class ::NTuple::Matrix<float>
10919 
10920 namespace ROOT {
10921  // Wrappers around operator new
10922  static void *new_NTuplecLcLMatrixlEdoublegR(void *p) {
10923  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<double> : new ::NTuple::Matrix<double>;
10924  }
10925  static void *newArray_NTuplecLcLMatrixlEdoublegR(Long_t nElements, void *p) {
10926  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Matrix<double>[nElements] : new ::NTuple::Matrix<double>[nElements];
10927  }
10928  // Wrapper around operator delete
10929  static void delete_NTuplecLcLMatrixlEdoublegR(void *p) {
10930  delete ((::NTuple::Matrix<double>*)p);
10931  }
10932  static void deleteArray_NTuplecLcLMatrixlEdoublegR(void *p) {
10933  delete [] ((::NTuple::Matrix<double>*)p);
10934  }
10935  static void destruct_NTuplecLcLMatrixlEdoublegR(void *p) {
10936  typedef ::NTuple::Matrix<double> current_t;
10937  ((current_t*)p)->~current_t();
10938  }
10939 } // end of namespace ROOT for class ::NTuple::Matrix<double>
10940 
10941 namespace ROOT {
10942  // Wrappers around operator new
10943  static void *new_NTuplecLcLItemlEboolgR(void *p) {
10944  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<bool> : new ::NTuple::Item<bool>;
10945  }
10946  static void *newArray_NTuplecLcLItemlEboolgR(Long_t nElements, void *p) {
10947  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Item<bool>[nElements] : new ::NTuple::Item<bool>[nElements];
10948  }
10949  // Wrapper around operator delete
10950  static void delete_NTuplecLcLItemlEboolgR(void *p) {
10951  delete ((::NTuple::Item<bool>*)p);
10952  }
10953  static void deleteArray_NTuplecLcLItemlEboolgR(void *p) {
10954  delete [] ((::NTuple::Item<bool>*)p);
10955  }
10956  static void destruct_NTuplecLcLItemlEboolgR(void *p) {
10957  typedef ::NTuple::Item<bool> current_t;
10958  ((current_t*)p)->~current_t();
10959  }
10960 } // end of namespace ROOT for class ::NTuple::Item<bool>
10961 
10962 namespace ROOT {
10963  // Wrappers around operator new
10964  static void *new_NTuplecLcLDirectory(void *p) {
10965  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Directory : new ::NTuple::Directory;
10966  }
10967  static void *newArray_NTuplecLcLDirectory(Long_t nElements, void *p) {
10968  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::Directory[nElements] : new ::NTuple::Directory[nElements];
10969  }
10970  // Wrapper around operator delete
10971  static void delete_NTuplecLcLDirectory(void *p) {
10972  delete ((::NTuple::Directory*)p);
10973  }
10974  static void deleteArray_NTuplecLcLDirectory(void *p) {
10975  delete [] ((::NTuple::Directory*)p);
10976  }
10977  static void destruct_NTuplecLcLDirectory(void *p) {
10978  typedef ::NTuple::Directory current_t;
10979  ((current_t*)p)->~current_t();
10980  }
10981 } // end of namespace ROOT for class ::NTuple::Directory
10982 
10983 namespace ROOT {
10984  // Wrappers around operator new
10985  static void *new_NTuplecLcLFile(void *p) {
10986  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::File : new ::NTuple::File;
10987  }
10988  static void *newArray_NTuplecLcLFile(Long_t nElements, void *p) {
10989  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::NTuple::File[nElements] : new ::NTuple::File[nElements];
10990  }
10991  // Wrapper around operator delete
10992  static void delete_NTuplecLcLFile(void *p) {
10993  delete ((::NTuple::File*)p);
10994  }
10995  static void deleteArray_NTuplecLcLFile(void *p) {
10996  delete [] ((::NTuple::File*)p);
10997  }
10998  static void destruct_NTuplecLcLFile(void *p) {
10999  typedef ::NTuple::File current_t;
11000  ((current_t*)p)->~current_t();
11001  }
11002 } // end of namespace ROOT for class ::NTuple::File
11003 
11004 namespace ROOT {
11005  // Wrapper around operator delete
11006  static void delete_NTuplecLcLArraylEIOpaqueAddressmUgR(void *p) {
11007  delete ((::NTuple::Array<IOpaqueAddress*>*)p);
11008  }
11009  static void deleteArray_NTuplecLcLArraylEIOpaqueAddressmUgR(void *p) {
11010  delete [] ((::NTuple::Array<IOpaqueAddress*>*)p);
11011  }
11012  static void destruct_NTuplecLcLArraylEIOpaqueAddressmUgR(void *p) {
11013  typedef ::NTuple::Array<IOpaqueAddress*> current_t;
11014  ((current_t*)p)->~current_t();
11015  }
11016 } // end of namespace ROOT for class ::NTuple::Array<IOpaqueAddress*>
11017 
11018 namespace ROOT {
11019  // Wrapper around operator delete
11020  static void delete_NTuplecLcLMatrixlEIOpaqueAddressmUgR(void *p) {
11021  delete ((::NTuple::Matrix<IOpaqueAddress*>*)p);
11022  }
11023  static void deleteArray_NTuplecLcLMatrixlEIOpaqueAddressmUgR(void *p) {
11024  delete [] ((::NTuple::Matrix<IOpaqueAddress*>*)p);
11025  }
11026  static void destruct_NTuplecLcLMatrixlEIOpaqueAddressmUgR(void *p) {
11027  typedef ::NTuple::Matrix<IOpaqueAddress*> current_t;
11028  ((current_t*)p)->~current_t();
11029  }
11030 } // end of namespace ROOT for class ::NTuple::Matrix<IOpaqueAddress*>
11031 
11032 namespace ROOT {
11033  // Wrapper around operator delete
11034  static void delete_NTuplecLcLColumnWiseTuple(void *p) {
11035  delete ((::NTuple::ColumnWiseTuple*)p);
11036  }
11037  static void deleteArray_NTuplecLcLColumnWiseTuple(void *p) {
11038  delete [] ((::NTuple::ColumnWiseTuple*)p);
11039  }
11040  static void destruct_NTuplecLcLColumnWiseTuple(void *p) {
11041  typedef ::NTuple::ColumnWiseTuple current_t;
11042  ((current_t*)p)->~current_t();
11043  }
11044 } // end of namespace ROOT for class ::NTuple::ColumnWiseTuple
11045 
11046 namespace ROOT {
11047  // Wrapper around operator delete
11048  static void delete_NTuplecLcLRowWiseTuple(void *p) {
11049  delete ((::NTuple::RowWiseTuple*)p);
11050  }
11051  static void deleteArray_NTuplecLcLRowWiseTuple(void *p) {
11052  delete [] ((::NTuple::RowWiseTuple*)p);
11053  }
11054  static void destruct_NTuplecLcLRowWiseTuple(void *p) {
11055  typedef ::NTuple::RowWiseTuple current_t;
11056  ((current_t*)p)->~current_t();
11057  }
11058 } // end of namespace ROOT for class ::NTuple::RowWiseTuple
11059 
11060 namespace ROOT {
11061  // Wrapper around operator delete
11062  static void delete_IRegistry(void *p) {
11063  delete ((::IRegistry*)p);
11064  }
11065  static void deleteArray_IRegistry(void *p) {
11066  delete [] ((::IRegistry*)p);
11067  }
11068  static void destruct_IRegistry(void *p) {
11069  typedef ::IRegistry current_t;
11070  ((current_t*)p)->~current_t();
11071  }
11072 } // end of namespace ROOT for class ::IRegistry
11073 
11074 namespace ROOT {
11075  // Wrapper around operator delete
11076  static void delete_RndmcLcLGauss(void *p) {
11077  delete ((::Rndm::Gauss*)p);
11078  }
11079  static void deleteArray_RndmcLcLGauss(void *p) {
11080  delete [] ((::Rndm::Gauss*)p);
11081  }
11082  static void destruct_RndmcLcLGauss(void *p) {
11083  typedef ::Rndm::Gauss current_t;
11084  ((current_t*)p)->~current_t();
11085  }
11086 } // end of namespace ROOT for class ::Rndm::Gauss
11087 
11088 namespace ROOT {
11089  // Wrapper around operator delete
11090  static void delete_RndmcLcLExponential(void *p) {
11091  delete ((::Rndm::Exponential*)p);
11092  }
11093  static void deleteArray_RndmcLcLExponential(void *p) {
11094  delete [] ((::Rndm::Exponential*)p);
11095  }
11096  static void destruct_RndmcLcLExponential(void *p) {
11097  typedef ::Rndm::Exponential current_t;
11098  ((current_t*)p)->~current_t();
11099  }
11100 } // end of namespace ROOT for class ::Rndm::Exponential
11101 
11102 namespace ROOT {
11103  // Wrapper around operator delete
11104  static void delete_RndmcLcLChi2(void *p) {
11105  delete ((::Rndm::Chi2*)p);
11106  }
11107  static void deleteArray_RndmcLcLChi2(void *p) {
11108  delete [] ((::Rndm::Chi2*)p);
11109  }
11110  static void destruct_RndmcLcLChi2(void *p) {
11111  typedef ::Rndm::Chi2 current_t;
11112  ((current_t*)p)->~current_t();
11113  }
11114 } // end of namespace ROOT for class ::Rndm::Chi2
11115 
11116 namespace ROOT {
11117  // Wrapper around operator delete
11118  static void delete_RndmcLcLBreitWigner(void *p) {
11119  delete ((::Rndm::BreitWigner*)p);
11120  }
11121  static void deleteArray_RndmcLcLBreitWigner(void *p) {
11122  delete [] ((::Rndm::BreitWigner*)p);
11123  }
11124  static void destruct_RndmcLcLBreitWigner(void *p) {
11125  typedef ::Rndm::BreitWigner current_t;
11126  ((current_t*)p)->~current_t();
11127  }
11128 } // end of namespace ROOT for class ::Rndm::BreitWigner
11129 
11130 namespace ROOT {
11131  // Wrapper around operator delete
11132  static void delete_RndmcLcLLandau(void *p) {
11133  delete ((::Rndm::Landau*)p);
11134  }
11135  static void deleteArray_RndmcLcLLandau(void *p) {
11136  delete [] ((::Rndm::Landau*)p);
11137  }
11138  static void destruct_RndmcLcLLandau(void *p) {
11139  typedef ::Rndm::Landau current_t;
11140  ((current_t*)p)->~current_t();
11141  }
11142 } // end of namespace ROOT for class ::Rndm::Landau
11143 
11144 namespace ROOT {
11145  // Wrapper around operator delete
11146  static void delete_RndmcLcLBreitWignerCutOff(void *p) {
11147  delete ((::Rndm::BreitWignerCutOff*)p);
11148  }
11149  static void deleteArray_RndmcLcLBreitWignerCutOff(void *p) {
11150  delete [] ((::Rndm::BreitWignerCutOff*)p);
11151  }
11152  static void destruct_RndmcLcLBreitWignerCutOff(void *p) {
11153  typedef ::Rndm::BreitWignerCutOff current_t;
11154  ((current_t*)p)->~current_t();
11155  }
11156 } // end of namespace ROOT for class ::Rndm::BreitWignerCutOff
11157 
11158 namespace ROOT {
11159  // Wrapper around operator delete
11160  static void delete_RndmcLcLStudentT(void *p) {
11161  delete ((::Rndm::StudentT*)p);
11162  }
11163  static void deleteArray_RndmcLcLStudentT(void *p) {
11164  delete [] ((::Rndm::StudentT*)p);
11165  }
11166  static void destruct_RndmcLcLStudentT(void *p) {
11167  typedef ::Rndm::StudentT current_t;
11168  ((current_t*)p)->~current_t();
11169  }
11170 } // end of namespace ROOT for class ::Rndm::StudentT
11171 
11172 namespace ROOT {
11173  // Wrapper around operator delete
11174  static void delete_RndmcLcLGamma(void *p) {
11175  delete ((::Rndm::Gamma*)p);
11176  }
11177  static void deleteArray_RndmcLcLGamma(void *p) {
11178  delete [] ((::Rndm::Gamma*)p);
11179  }
11180  static void destruct_RndmcLcLGamma(void *p) {
11181  typedef ::Rndm::Gamma current_t;
11182  ((current_t*)p)->~current_t();
11183  }
11184 } // end of namespace ROOT for class ::Rndm::Gamma
11185 
11186 namespace ROOT {
11187  // Wrapper around operator delete
11188  static void delete_RndmcLcLPoisson(void *p) {
11189  delete ((::Rndm::Poisson*)p);
11190  }
11191  static void deleteArray_RndmcLcLPoisson(void *p) {
11192  delete [] ((::Rndm::Poisson*)p);
11193  }
11194  static void destruct_RndmcLcLPoisson(void *p) {
11195  typedef ::Rndm::Poisson current_t;
11196  ((current_t*)p)->~current_t();
11197  }
11198 } // end of namespace ROOT for class ::Rndm::Poisson
11199 
11200 namespace ROOT {
11201  // Wrapper around operator delete
11202  static void delete_RndmcLcLBinomial(void *p) {
11203  delete ((::Rndm::Binomial*)p);
11204  }
11205  static void deleteArray_RndmcLcLBinomial(void *p) {
11206  delete [] ((::Rndm::Binomial*)p);
11207  }
11208  static void destruct_RndmcLcLBinomial(void *p) {
11209  typedef ::Rndm::Binomial current_t;
11210  ((current_t*)p)->~current_t();
11211  }
11212 } // end of namespace ROOT for class ::Rndm::Binomial
11213 
11214 namespace ROOT {
11215  // Wrapper around operator delete
11216  static void delete_RndmcLcLFlat(void *p) {
11217  delete ((::Rndm::Flat*)p);
11218  }
11219  static void deleteArray_RndmcLcLFlat(void *p) {
11220  delete [] ((::Rndm::Flat*)p);
11221  }
11222  static void destruct_RndmcLcLFlat(void *p) {
11223  typedef ::Rndm::Flat current_t;
11224  ((current_t*)p)->~current_t();
11225  }
11226 } // end of namespace ROOT for class ::Rndm::Flat
11227 
11228 namespace ROOT {
11229  // Wrappers around operator new
11230  static void *new_RndmcLcLBit(void *p) {
11231  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Rndm::Bit : new ::Rndm::Bit;
11232  }
11233  static void *newArray_RndmcLcLBit(Long_t nElements, void *p) {
11234  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Rndm::Bit[nElements] : new ::Rndm::Bit[nElements];
11235  }
11236  // Wrapper around operator delete
11237  static void delete_RndmcLcLBit(void *p) {
11238  delete ((::Rndm::Bit*)p);
11239  }
11240  static void deleteArray_RndmcLcLBit(void *p) {
11241  delete [] ((::Rndm::Bit*)p);
11242  }
11243  static void destruct_RndmcLcLBit(void *p) {
11244  typedef ::Rndm::Bit current_t;
11245  ((current_t*)p)->~current_t();
11246  }
11247 } // end of namespace ROOT for class ::Rndm::Bit
11248 
11249 namespace ROOT {
11250  // Wrapper around operator delete
11251  static void delete_RndmcLcLDefinedPdf(void *p) {
11252  delete ((::Rndm::DefinedPdf*)p);
11253  }
11254  static void deleteArray_RndmcLcLDefinedPdf(void *p) {
11255  delete [] ((::Rndm::DefinedPdf*)p);
11256  }
11257  static void destruct_RndmcLcLDefinedPdf(void *p) {
11258  typedef ::Rndm::DefinedPdf current_t;
11259  ((current_t*)p)->~current_t();
11260  }
11261 } // end of namespace ROOT for class ::Rndm::DefinedPdf
11262 
11263 namespace ROOT {
11264  // Wrapper around operator delete
11265  static void delete_RndmcLcLGaussianTail(void *p) {
11266  delete ((::Rndm::GaussianTail*)p);
11267  }
11268  static void deleteArray_RndmcLcLGaussianTail(void *p) {
11269  delete [] ((::Rndm::GaussianTail*)p);
11270  }
11271  static void destruct_RndmcLcLGaussianTail(void *p) {
11272  typedef ::Rndm::GaussianTail current_t;
11273  ((current_t*)p)->~current_t();
11274  }
11275 } // end of namespace ROOT for class ::Rndm::GaussianTail
11276 
11277 namespace ROOT {
11278  // Wrappers around operator new
11279  static void *new_RndmcLcLNumbers(void *p) {
11280  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Rndm::Numbers : new ::Rndm::Numbers;
11281  }
11282  static void *newArray_RndmcLcLNumbers(Long_t nElements, void *p) {
11283  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Rndm::Numbers[nElements] : new ::Rndm::Numbers[nElements];
11284  }
11285  // Wrapper around operator delete
11286  static void delete_RndmcLcLNumbers(void *p) {
11287  delete ((::Rndm::Numbers*)p);
11288  }
11289  static void deleteArray_RndmcLcLNumbers(void *p) {
11290  delete [] ((::Rndm::Numbers*)p);
11291  }
11292  static void destruct_RndmcLcLNumbers(void *p) {
11293  typedef ::Rndm::Numbers current_t;
11294  ((current_t*)p)->~current_t();
11295  }
11296 } // end of namespace ROOT for class ::Rndm::Numbers
11297 
11298 namespace ROOT {
11299  // Wrappers around operator new
11300  static void *new_SmartRefVectorlEDataObjectgR(void *p) {
11301  return p ? new(p) ::SmartRefVector<DataObject> : new ::SmartRefVector<DataObject>;
11302  }
11303  static void *newArray_SmartRefVectorlEDataObjectgR(Long_t nElements, void *p) {
11304  return p ? new(p) ::SmartRefVector<DataObject>[nElements] : new ::SmartRefVector<DataObject>[nElements];
11305  }
11306  // Wrapper around operator delete
11307  static void delete_SmartRefVectorlEDataObjectgR(void *p) {
11308  delete ((::SmartRefVector<DataObject>*)p);
11309  }
11310  static void deleteArray_SmartRefVectorlEDataObjectgR(void *p) {
11311  delete [] ((::SmartRefVector<DataObject>*)p);
11312  }
11313  static void destruct_SmartRefVectorlEDataObjectgR(void *p) {
11314  typedef ::SmartRefVector<DataObject> current_t;
11315  ((current_t*)p)->~current_t();
11316  }
11317 } // end of namespace ROOT for class ::SmartRefVector<DataObject>
11318 
11319 namespace ROOT {
11320  // Wrappers around operator new
11321  static void *new_SmartRefVectorlEContainedObjectgR(void *p) {
11322  return p ? new(p) ::SmartRefVector<ContainedObject> : new ::SmartRefVector<ContainedObject>;
11323  }
11324  static void *newArray_SmartRefVectorlEContainedObjectgR(Long_t nElements, void *p) {
11325  return p ? new(p) ::SmartRefVector<ContainedObject>[nElements] : new ::SmartRefVector<ContainedObject>[nElements];
11326  }
11327  // Wrapper around operator delete
11328  static void delete_SmartRefVectorlEContainedObjectgR(void *p) {
11329  delete ((::SmartRefVector<ContainedObject>*)p);
11330  }
11331  static void deleteArray_SmartRefVectorlEContainedObjectgR(void *p) {
11332  delete [] ((::SmartRefVector<ContainedObject>*)p);
11333  }
11334  static void destruct_SmartRefVectorlEContainedObjectgR(void *p) {
11335  typedef ::SmartRefVector<ContainedObject> current_t;
11336  ((current_t*)p)->~current_t();
11337  }
11338 } // end of namespace ROOT for class ::SmartRefVector<ContainedObject>
11339 
11340 namespace ROOT {
11341  // Wrappers around operator new
11342  static void *new_SmartRefVectorlEObjectContainerBasegR(void *p) {
11343  return p ? new(p) ::SmartRefVector<ObjectContainerBase> : new ::SmartRefVector<ObjectContainerBase>;
11344  }
11345  static void *newArray_SmartRefVectorlEObjectContainerBasegR(Long_t nElements, void *p) {
11346  return p ? new(p) ::SmartRefVector<ObjectContainerBase>[nElements] : new ::SmartRefVector<ObjectContainerBase>[nElements];
11347  }
11348  // Wrapper around operator delete
11349  static void delete_SmartRefVectorlEObjectContainerBasegR(void *p) {
11350  delete ((::SmartRefVector<ObjectContainerBase>*)p);
11351  }
11352  static void deleteArray_SmartRefVectorlEObjectContainerBasegR(void *p) {
11353  delete [] ((::SmartRefVector<ObjectContainerBase>*)p);
11354  }
11355  static void destruct_SmartRefVectorlEObjectContainerBasegR(void *p) {
11356  typedef ::SmartRefVector<ObjectContainerBase> current_t;
11357  ((current_t*)p)->~current_t();
11358  }
11359 } // end of namespace ROOT for class ::SmartRefVector<ObjectContainerBase>
11360 
11361 namespace ROOT {
11362  // Wrappers around operator new
11363  static void *new_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p) {
11364  return p ? new(p) ::SmartRefVector<KeyedObject<int> > : new ::SmartRefVector<KeyedObject<int> >;
11365  }
11366  static void *newArray_SmartRefVectorlEKeyedObjectlEintgRsPgR(Long_t nElements, void *p) {
11367  return p ? new(p) ::SmartRefVector<KeyedObject<int> >[nElements] : new ::SmartRefVector<KeyedObject<int> >[nElements];
11368  }
11369  // Wrapper around operator delete
11370  static void delete_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p) {
11371  delete ((::SmartRefVector<KeyedObject<int> >*)p);
11372  }
11373  static void deleteArray_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p) {
11374  delete [] ((::SmartRefVector<KeyedObject<int> >*)p);
11375  }
11376  static void destruct_SmartRefVectorlEKeyedObjectlEintgRsPgR(void *p) {
11377  typedef ::SmartRefVector<KeyedObject<int> > current_t;
11378  ((current_t*)p)->~current_t();
11379  }
11380 } // end of namespace ROOT for class ::SmartRefVector<KeyedObject<int> >
11381 
11382 namespace ROOT {
11383  // Wrappers around operator new
11384  static void *new_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
11385  return p ? new(p) ::SmartRefVector<KeyedObject<unsigned int> > : new ::SmartRefVector<KeyedObject<unsigned int> >;
11386  }
11387  static void *newArray_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(Long_t nElements, void *p) {
11388  return p ? new(p) ::SmartRefVector<KeyedObject<unsigned int> >[nElements] : new ::SmartRefVector<KeyedObject<unsigned int> >[nElements];
11389  }
11390  // Wrapper around operator delete
11391  static void delete_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
11392  delete ((::SmartRefVector<KeyedObject<unsigned int> >*)p);
11393  }
11394  static void deleteArray_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
11395  delete [] ((::SmartRefVector<KeyedObject<unsigned int> >*)p);
11396  }
11397  static void destruct_SmartRefVectorlEKeyedObjectlEunsignedsPintgRsPgR(void *p) {
11398  typedef ::SmartRefVector<KeyedObject<unsigned int> > current_t;
11399  ((current_t*)p)->~current_t();
11400  }
11401 } // end of namespace ROOT for class ::SmartRefVector<KeyedObject<unsigned int> >
11402 
11403 namespace ROOT {
11404  // Wrappers around operator new
11405  static void *new_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p) {
11406  return p ? new(p) ::SmartRefVector<KeyedObject<long> > : new ::SmartRefVector<KeyedObject<long> >;
11407  }
11408  static void *newArray_SmartRefVectorlEKeyedObjectlElonggRsPgR(Long_t nElements, void *p) {
11409  return p ? new(p) ::SmartRefVector<KeyedObject<long> >[nElements] : new ::SmartRefVector<KeyedObject<long> >[nElements];
11410  }
11411  // Wrapper around operator delete
11412  static void delete_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p) {
11413  delete ((::SmartRefVector<KeyedObject<long> >*)p);
11414  }
11415  static void deleteArray_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p) {
11416  delete [] ((::SmartRefVector<KeyedObject<long> >*)p);
11417  }
11418  static void destruct_SmartRefVectorlEKeyedObjectlElonggRsPgR(void *p) {
11419  typedef ::SmartRefVector<KeyedObject<long> > current_t;
11420  ((current_t*)p)->~current_t();
11421  }
11422 } // end of namespace ROOT for class ::SmartRefVector<KeyedObject<long> >
11423 
11424 namespace ROOT {
11425  // Wrappers around operator new
11426  static void *new_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
11427  return p ? new(p) ::SmartRefVector<KeyedObject<unsigned long> > : new ::SmartRefVector<KeyedObject<unsigned long> >;
11428  }
11429  static void *newArray_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(Long_t nElements, void *p) {
11430  return p ? new(p) ::SmartRefVector<KeyedObject<unsigned long> >[nElements] : new ::SmartRefVector<KeyedObject<unsigned long> >[nElements];
11431  }
11432  // Wrapper around operator delete
11433  static void delete_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
11434  delete ((::SmartRefVector<KeyedObject<unsigned long> >*)p);
11435  }
11436  static void deleteArray_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
11437  delete [] ((::SmartRefVector<KeyedObject<unsigned long> >*)p);
11438  }
11439  static void destruct_SmartRefVectorlEKeyedObjectlEunsignedsPlonggRsPgR(void *p) {
11440  typedef ::SmartRefVector<KeyedObject<unsigned long> > current_t;
11441  ((current_t*)p)->~current_t();
11442  }
11443 } // end of namespace ROOT for class ::SmartRefVector<KeyedObject<unsigned long> >
11444 
11445 namespace ROOT {
11446  // Wrappers around operator new
11447  static void *new_GaudicLcLTime(void *p) {
11448  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Time : new ::Gaudi::Time;
11449  }
11450  static void *newArray_GaudicLcLTime(Long_t nElements, void *p) {
11451  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Time[nElements] : new ::Gaudi::Time[nElements];
11452  }
11453  // Wrapper around operator delete
11454  static void delete_GaudicLcLTime(void *p) {
11455  delete ((::Gaudi::Time*)p);
11456  }
11457  static void deleteArray_GaudicLcLTime(void *p) {
11458  delete [] ((::Gaudi::Time*)p);
11459  }
11460  static void destruct_GaudicLcLTime(void *p) {
11461  typedef ::Gaudi::Time current_t;
11462  ((current_t*)p)->~current_t();
11463  }
11464 } // end of namespace ROOT for class ::Gaudi::Time
11465 
11466 namespace ROOT {
11467  // Wrapper around operator delete
11468  static void delete_DataObjectHandleBase(void *p) {
11469  delete ((::DataObjectHandleBase*)p);
11470  }
11471  static void deleteArray_DataObjectHandleBase(void *p) {
11472  delete [] ((::DataObjectHandleBase*)p);
11473  }
11474  static void destruct_DataObjectHandleBase(void *p) {
11475  typedef ::DataObjectHandleBase current_t;
11476  ((current_t*)p)->~current_t();
11477  }
11478 } // end of namespace ROOT for class ::DataObjectHandleBase
11479 
11480 namespace ROOT {
11481  // Wrapper around operator delete
11482  static void delete_IAddressCreator(void *p) {
11483  delete ((::IAddressCreator*)p);
11484  }
11485  static void deleteArray_IAddressCreator(void *p) {
11486  delete [] ((::IAddressCreator*)p);
11487  }
11488  static void destruct_IAddressCreator(void *p) {
11489  typedef ::IAddressCreator current_t;
11490  ((current_t*)p)->~current_t();
11491  }
11492 } // end of namespace ROOT for class ::IAddressCreator
11493 
11494 namespace ROOT {
11495  // Wrapper around operator delete
11496  static void delete_IAlgManager(void *p) {
11497  delete ((::IAlgManager*)p);
11498  }
11499  static void deleteArray_IAlgManager(void *p) {
11500  delete [] ((::IAlgManager*)p);
11501  }
11502  static void destruct_IAlgManager(void *p) {
11503  typedef ::IAlgManager current_t;
11504  ((current_t*)p)->~current_t();
11505  }
11506 } // end of namespace ROOT for class ::IAlgManager
11507 
11508 namespace ROOT {
11509  // Wrapper around operator delete
11510  static void delete_IAppMgrUI(void *p) {
11511  delete ((::IAppMgrUI*)p);
11512  }
11513  static void deleteArray_IAppMgrUI(void *p) {
11514  delete [] ((::IAppMgrUI*)p);
11515  }
11516  static void destruct_IAppMgrUI(void *p) {
11517  typedef ::IAppMgrUI current_t;
11518  ((current_t*)p)->~current_t();
11519  }
11520 } // end of namespace ROOT for class ::IAppMgrUI
11521 
11522 namespace ROOT {
11523  // Wrapper around operator delete
11524  static void delete_IClassInfo(void *p) {
11525  delete ((::IClassInfo*)p);
11526  }
11527  static void deleteArray_IClassInfo(void *p) {
11528  delete [] ((::IClassInfo*)p);
11529  }
11530  static void destruct_IClassInfo(void *p) {
11531  typedef ::IClassInfo current_t;
11532  ((current_t*)p)->~current_t();
11533  }
11534 } // end of namespace ROOT for class ::IClassInfo
11535 
11536 namespace ROOT {
11537  // Wrapper around operator delete
11538  static void delete_IClassManager(void *p) {
11539  delete ((::IClassManager*)p);
11540  }
11541  static void deleteArray_IClassManager(void *p) {
11542  delete [] ((::IClassManager*)p);
11543  }
11544  static void destruct_IClassManager(void *p) {
11545  typedef ::IClassManager current_t;
11546  ((current_t*)p)->~current_t();
11547  }
11548 } // end of namespace ROOT for class ::IClassManager
11549 
11550 namespace ROOT {
11551  // Wrapper around operator delete
11552  static void delete_ICounterSummarySvc(void *p) {
11553  delete ((::ICounterSummarySvc*)p);
11554  }
11555  static void deleteArray_ICounterSummarySvc(void *p) {
11556  delete [] ((::ICounterSummarySvc*)p);
11557  }
11558  static void destruct_ICounterSummarySvc(void *p) {
11559  typedef ::ICounterSummarySvc current_t;
11560  ((current_t*)p)->~current_t();
11561  }
11562 } // end of namespace ROOT for class ::ICounterSummarySvc
11563 
11564 namespace ROOT {
11565  // Wrapper around operator delete
11566  static void delete_IDataManagerSvc(void *p) {
11567  delete ((::IDataManagerSvc*)p);
11568  }
11569  static void deleteArray_IDataManagerSvc(void *p) {
11570  delete [] ((::IDataManagerSvc*)p);
11571  }
11572  static void destruct_IDataManagerSvc(void *p) {
11573  typedef ::IDataManagerSvc current_t;
11574  ((current_t*)p)->~current_t();
11575  }
11576 } // end of namespace ROOT for class ::IDataManagerSvc
11577 
11578 namespace ROOT {
11579  // Wrapper around operator delete
11580  static void delete_IDataSourceMgr(void *p) {
11581  delete ((::IDataSourceMgr*)p);
11582  }
11583  static void deleteArray_IDataSourceMgr(void *p) {
11584  delete [] ((::IDataSourceMgr*)p);
11585  }
11586  static void destruct_IDataSourceMgr(void *p) {
11587  typedef ::IDataSourceMgr current_t;
11588  ((current_t*)p)->~current_t();
11589  }
11590 } // end of namespace ROOT for class ::IDataSourceMgr
11591 
11592 namespace ROOT {
11593  // Wrapper around operator delete
11594  static void delete_IDataStoreAgent(void *p) {
11595  delete ((::IDataStoreAgent*)p);
11596  }
11597  static void deleteArray_IDataStoreAgent(void *p) {
11598  delete [] ((::IDataStoreAgent*)p);
11599  }
11600  static void destruct_IDataStoreAgent(void *p) {
11601  typedef ::IDataStoreAgent current_t;
11602  ((current_t*)p)->~current_t();
11603  }
11604 } // end of namespace ROOT for class ::IDataStoreAgent
11605 
11606 namespace ROOT {
11607  // Wrapper around operator delete
11608  static void delete_IDataStoreLeaves(void *p) {
11609  delete ((::IDataStoreLeaves*)p);
11610  }
11611  static void deleteArray_IDataStoreLeaves(void *p) {
11612  delete [] ((::IDataStoreLeaves*)p);
11613  }
11614  static void destruct_IDataStoreLeaves(void *p) {
11615  typedef ::IDataStoreLeaves current_t;
11616  ((current_t*)p)->~current_t();
11617  }
11618 } // end of namespace ROOT for class ::IDataStoreLeaves
11619 
11620 namespace ROOT {
11621  // Wrapper around operator delete
11622  static void delete_IDetDataSvc(void *p) {
11623  delete ((::IDetDataSvc*)p);
11624  }
11625  static void deleteArray_IDetDataSvc(void *p) {
11626  delete [] ((::IDetDataSvc*)p);
11627  }
11628  static void destruct_IDetDataSvc(void *p) {
11629  typedef ::IDetDataSvc current_t;
11630  ((current_t*)p)->~current_t();
11631  }
11632 } // end of namespace ROOT for class ::IDetDataSvc
11633 
11634 namespace ROOT {
11635  // Wrapper around operator delete
11636  static void delete_IEventProcessor(void *p) {
11637  delete ((::IEventProcessor*)p);
11638  }
11639  static void deleteArray_IEventProcessor(void *p) {
11640  delete [] ((::IEventProcessor*)p);
11641  }
11642  static void destruct_IEventProcessor(void *p) {
11643  typedef ::IEventProcessor current_t;
11644  ((current_t*)p)->~current_t();
11645  }
11646 } // end of namespace ROOT for class ::IEventProcessor
11647 
11648 namespace ROOT {
11649  // Wrapper around operator delete
11650  static void delete_IEventTimeDecoder(void *p) {
11651  delete ((::IEventTimeDecoder*)p);
11652  }
11653  static void deleteArray_IEventTimeDecoder(void *p) {
11654  delete [] ((::IEventTimeDecoder*)p);
11655  }
11656  static void destruct_IEventTimeDecoder(void *p) {
11657  typedef ::IEventTimeDecoder current_t;
11658  ((current_t*)p)->~current_t();
11659  }
11660 } // end of namespace ROOT for class ::IEventTimeDecoder
11661 
11662 namespace ROOT {
11663  // Wrapper around operator delete
11664  static void delete_IHistorySvc(void *p) {
11665  delete ((::IHistorySvc*)p);
11666  }
11667  static void deleteArray_IHistorySvc(void *p) {
11668  delete [] ((::IHistorySvc*)p);
11669  }
11670  static void destruct_IHistorySvc(void *p) {
11671  typedef ::IHistorySvc current_t;
11672  ((current_t*)p)->~current_t();
11673  }
11674 } // end of namespace ROOT for class ::IHistorySvc
11675 
11676 namespace ROOT {
11677  // Wrapper around operator delete
11678  static void delete_IIncidentListener(void *p) {
11679  delete ((::IIncidentListener*)p);
11680  }
11681  static void deleteArray_IIncidentListener(void *p) {
11682  delete [] ((::IIncidentListener*)p);
11683  }
11684  static void destruct_IIncidentListener(void *p) {
11685  typedef ::IIncidentListener current_t;
11686  ((current_t*)p)->~current_t();
11687  }
11688 } // end of namespace ROOT for class ::IIncidentListener
11689 
11690 namespace ROOT {
11691  // Wrapper around operator delete
11692  static void delete_IInspectable(void *p) {
11693  delete ((::IInspectable*)p);
11694  }
11695  static void deleteArray_IInspectable(void *p) {
11696  delete [] ((::IInspectable*)p);
11697  }
11698  static void destruct_IInspectable(void *p) {
11699  typedef ::IInspectable current_t;
11700  ((current_t*)p)->~current_t();
11701  }
11702 } // end of namespace ROOT for class ::IInspectable
11703 
11704 namespace ROOT {
11705  // Wrapper around operator delete
11706  static void delete_IInspector(void *p) {
11707  delete ((::IInspector*)p);
11708  }
11709  static void deleteArray_IInspector(void *p) {
11710  delete [] ((::IInspector*)p);
11711  }
11712  static void destruct_IInspector(void *p) {
11713  typedef ::IInspector current_t;
11714  ((current_t*)p)->~current_t();
11715  }
11716 } // end of namespace ROOT for class ::IInspector
11717 
11718 namespace ROOT {
11719  // Wrapper around operator delete
11720  static void delete_IJobOptionsSvc(void *p) {
11721  delete ((::IJobOptionsSvc*)p);
11722  }
11723  static void deleteArray_IJobOptionsSvc(void *p) {
11724  delete [] ((::IJobOptionsSvc*)p);
11725  }
11726  static void destruct_IJobOptionsSvc(void *p) {
11727  typedef ::IJobOptionsSvc current_t;
11728  ((current_t*)p)->~current_t();
11729  }
11730 } // end of namespace ROOT for class ::IJobOptionsSvc
11731 
11732 namespace ROOT {
11733  // Wrapper around operator delete
11734  static void delete_IMagneticFieldSvc(void *p) {
11735  delete ((::IMagneticFieldSvc*)p);
11736  }
11737  static void deleteArray_IMagneticFieldSvc(void *p) {
11738  delete [] ((::IMagneticFieldSvc*)p);
11739  }
11740  static void destruct_IMagneticFieldSvc(void *p) {
11741  typedef ::IMagneticFieldSvc current_t;
11742  ((current_t*)p)->~current_t();
11743  }
11744 } // end of namespace ROOT for class ::IMagneticFieldSvc
11745 
11746 namespace ROOT {
11747  // Wrapper around operator delete
11748  static void delete_IPartPropSvc(void *p) {
11749  delete ((::IPartPropSvc*)p);
11750  }
11751  static void deleteArray_IPartPropSvc(void *p) {
11752  delete [] ((::IPartPropSvc*)p);
11753  }
11754  static void destruct_IPartPropSvc(void *p) {
11755  typedef ::IPartPropSvc current_t;
11756  ((current_t*)p)->~current_t();
11757  }
11758 } // end of namespace ROOT for class ::IPartPropSvc
11759 
11760 namespace ROOT {
11761  // Wrapper around operator delete
11762  static void delete_IParticlePropertySvc(void *p) {
11763  delete ((::IParticlePropertySvc*)p);
11764  }
11765  static void deleteArray_IParticlePropertySvc(void *p) {
11766  delete [] ((::IParticlePropertySvc*)p);
11767  }
11768  static void destruct_IParticlePropertySvc(void *p) {
11769  typedef ::IParticlePropertySvc current_t;
11770  ((current_t*)p)->~current_t();
11771  }
11772 } // end of namespace ROOT for class ::IParticlePropertySvc
11773 
11774 namespace ROOT {
11775  // Wrapper around operator delete
11776  static void delete_IPartitionControl(void *p) {
11777  delete ((::IPartitionControl*)p);
11778  }
11779  static void deleteArray_IPartitionControl(void *p) {
11780  delete [] ((::IPartitionControl*)p);
11781  }
11782  static void destruct_IPartitionControl(void *p) {
11783  typedef ::IPartitionControl current_t;
11784  ((current_t*)p)->~current_t();
11785  }
11786 } // end of namespace ROOT for class ::IPartitionControl
11787 
11788 namespace ROOT {
11789  // Wrapper around operator delete
11790  static void delete_IPersistencySvc(void *p) {
11791  delete ((::IPersistencySvc*)p);
11792  }
11793  static void deleteArray_IPersistencySvc(void *p) {
11794  delete [] ((::IPersistencySvc*)p);
11795  }
11796  static void destruct_IPersistencySvc(void *p) {
11797  typedef ::IPersistencySvc current_t;
11798  ((current_t*)p)->~current_t();
11799  }
11800 } // end of namespace ROOT for class ::IPersistencySvc
11801 
11802 namespace ROOT {
11803  // Wrapper around operator delete
11804  static void delete_IRndmEngine(void *p) {
11805  delete ((::IRndmEngine*)p);
11806  }
11807  static void deleteArray_IRndmEngine(void *p) {
11808  delete [] ((::IRndmEngine*)p);
11809  }
11810  static void destruct_IRndmEngine(void *p) {
11811  typedef ::IRndmEngine current_t;
11812  ((current_t*)p)->~current_t();
11813  }
11814 } // end of namespace ROOT for class ::IRndmEngine
11815 
11816 namespace ROOT {
11817  // Wrapper around operator delete
11818  static void delete_IRunable(void *p) {
11819  delete ((::IRunable*)p);
11820  }
11821  static void deleteArray_IRunable(void *p) {
11822  delete [] ((::IRunable*)p);
11823  }
11824  static void destruct_IRunable(void *p) {
11825  typedef ::IRunable current_t;
11826  ((current_t*)p)->~current_t();
11827  }
11828 } // end of namespace ROOT for class ::IRunable
11829 
11830 namespace ROOT {
11831  // Wrapper around operator delete
11832  static void delete_ISelectStatement(void *p) {
11833  delete ((::ISelectStatement*)p);
11834  }
11835  static void deleteArray_ISelectStatement(void *p) {
11836  delete [] ((::ISelectStatement*)p);
11837  }
11838  static void destruct_ISelectStatement(void *p) {
11839  typedef ::ISelectStatement current_t;
11840  ((current_t*)p)->~current_t();
11841  }
11842 } // end of namespace ROOT for class ::ISelectStatement
11843 
11844 namespace ROOT {
11845  // Wrapper around operator delete
11846  static void delete_ISerialize(void *p) {
11847  delete ((::ISerialize*)p);
11848  }
11849  static void deleteArray_ISerialize(void *p) {
11850  delete [] ((::ISerialize*)p);
11851  }
11852  static void destruct_ISerialize(void *p) {
11853  typedef ::ISerialize current_t;
11854  ((current_t*)p)->~current_t();
11855  }
11856 } // end of namespace ROOT for class ::ISerialize
11857 
11858 namespace ROOT {
11859  // Wrapper around operator delete
11860  static void delete_IStagerSvc(void *p) {
11861  delete ((::IStagerSvc*)p);
11862  }
11863  static void deleteArray_IStagerSvc(void *p) {
11864  delete [] ((::IStagerSvc*)p);
11865  }
11866  static void destruct_IStagerSvc(void *p) {
11867  typedef ::IStagerSvc current_t;
11868  ((current_t*)p)->~current_t();
11869  }
11870 } // end of namespace ROOT for class ::IStagerSvc
11871 
11872 namespace ROOT {
11873  // Wrapper around operator delete
11874  static void delete_IStatusCodeSvc(void *p) {
11875  delete ((::IStatusCodeSvc*)p);
11876  }
11877  static void deleteArray_IStatusCodeSvc(void *p) {
11878  delete [] ((::IStatusCodeSvc*)p);
11879  }
11880  static void destruct_IStatusCodeSvc(void *p) {
11881  typedef ::IStatusCodeSvc current_t;
11882  ((current_t*)p)->~current_t();
11883  }
11884 } // end of namespace ROOT for class ::IStatusCodeSvc
11885 
11886 namespace ROOT {
11887  // Wrapper around operator delete
11888  static void delete_ITHistSvc(void *p) {
11889  delete ((::ITHistSvc*)p);
11890  }
11891  static void deleteArray_ITHistSvc(void *p) {
11892  delete [] ((::ITHistSvc*)p);
11893  }
11894  static void destruct_ITHistSvc(void *p) {
11895  typedef ::ITHistSvc current_t;
11896  ((current_t*)p)->~current_t();
11897  }
11898 } // end of namespace ROOT for class ::ITHistSvc
11899 
11900 namespace ROOT {
11901  // Wrapper around operator delete
11902  static void delete_IUpdateManagerSvc(void *p) {
11903  delete ((::IUpdateManagerSvc*)p);
11904  }
11905  static void deleteArray_IUpdateManagerSvc(void *p) {
11906  delete [] ((::IUpdateManagerSvc*)p);
11907  }
11908  static void destruct_IUpdateManagerSvc(void *p) {
11909  typedef ::IUpdateManagerSvc current_t;
11910  ((current_t*)p)->~current_t();
11911  }
11912 } // end of namespace ROOT for class ::IUpdateManagerSvc
11913 
11914 namespace ROOT {
11915  // Wrapper around operator delete
11916  static void delete_IUpdateable(void *p) {
11917  delete ((::IUpdateable*)p);
11918  }
11919  static void deleteArray_IUpdateable(void *p) {
11920  delete [] ((::IUpdateable*)p);
11921  }
11922  static void destruct_IUpdateable(void *p) {
11923  typedef ::IUpdateable current_t;
11924  ((current_t*)p)->~current_t();
11925  }
11926 } // end of namespace ROOT for class ::IUpdateable
11927 
11928 namespace ROOT {
11929  // Wrapper around operator delete
11930  static void delete_IValidity(void *p) {
11931  delete ((::IValidity*)p);
11932  }
11933  static void deleteArray_IValidity(void *p) {
11934  delete [] ((::IValidity*)p);
11935  }
11936  static void destruct_IValidity(void *p) {
11937  typedef ::IValidity current_t;
11938  ((current_t*)p)->~current_t();
11939  }
11940 } // end of namespace ROOT for class ::IValidity
11941 
11942 namespace ROOT {
11943  // Wrappers around operator new
11944  static void *new_IUpdateManagerSvccLcLPythonHelper(void *p) {
11945  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::IUpdateManagerSvc::PythonHelper : new ::IUpdateManagerSvc::PythonHelper;
11946  }
11947  static void *newArray_IUpdateManagerSvccLcLPythonHelper(Long_t nElements, void *p) {
11948  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::IUpdateManagerSvc::PythonHelper[nElements] : new ::IUpdateManagerSvc::PythonHelper[nElements];
11949  }
11950  // Wrapper around operator delete
11951  static void delete_IUpdateManagerSvccLcLPythonHelper(void *p) {
11952  delete ((::IUpdateManagerSvc::PythonHelper*)p);
11953  }
11954  static void deleteArray_IUpdateManagerSvccLcLPythonHelper(void *p) {
11955  delete [] ((::IUpdateManagerSvc::PythonHelper*)p);
11956  }
11957  static void destruct_IUpdateManagerSvccLcLPythonHelper(void *p) {
11958  typedef ::IUpdateManagerSvc::PythonHelper current_t;
11959  ((current_t*)p)->~current_t();
11960  }
11961 } // end of namespace ROOT for class ::IUpdateManagerSvc::PythonHelper
11962 
11963 namespace ROOT {
11964  static TClass *vectorlEconstsPContainedObjectmUgR_Dictionary();
11965  static void vectorlEconstsPContainedObjectmUgR_TClassManip(TClass*);
11966  static void *new_vectorlEconstsPContainedObjectmUgR(void *p = 0);
11967  static void *newArray_vectorlEconstsPContainedObjectmUgR(Long_t size, void *p);
11968  static void delete_vectorlEconstsPContainedObjectmUgR(void *p);
11969  static void deleteArray_vectorlEconstsPContainedObjectmUgR(void *p);
11970  static void destruct_vectorlEconstsPContainedObjectmUgR(void *p);
11971 
11972  // Function generating the singleton type initializer
11973  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<const ContainedObject*>*)
11974  {
11975  vector<const ContainedObject*> *ptr = 0;
11976  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<const ContainedObject*>));
11977  static ::ROOT::TGenericClassInfo
11978  instance("vector<const ContainedObject*>", -2, "vector", 214,
11979  typeid(vector<const ContainedObject*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
11980  &vectorlEconstsPContainedObjectmUgR_Dictionary, isa_proxy, 4,
11981  sizeof(vector<const ContainedObject*>) );
11982  instance.SetNew(&new_vectorlEconstsPContainedObjectmUgR);
11983  instance.SetNewArray(&newArray_vectorlEconstsPContainedObjectmUgR);
11984  instance.SetDelete(&delete_vectorlEconstsPContainedObjectmUgR);
11985  instance.SetDeleteArray(&deleteArray_vectorlEconstsPContainedObjectmUgR);
11986  instance.SetDestructor(&destruct_vectorlEconstsPContainedObjectmUgR);
11987  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<const ContainedObject*> >()));
11988  return &instance;
11989  }
11990  // Static variable to force the class initialization
11991  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<const ContainedObject*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
11992 
11993  // Dictionary for non-ClassDef classes
11994  static TClass *vectorlEconstsPContainedObjectmUgR_Dictionary() {
11995  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<const ContainedObject*>*)0x0)->GetClass();
11996  vectorlEconstsPContainedObjectmUgR_TClassManip(theClass);
11997  return theClass;
11998  }
11999 
12000  static void vectorlEconstsPContainedObjectmUgR_TClassManip(TClass* ){
12001  }
12002 
12003 } // end of namespace ROOT
12004 
12005 namespace ROOT {
12006  // Wrappers around operator new
12007  static void *new_vectorlEconstsPContainedObjectmUgR(void *p) {
12008  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<const ContainedObject*> : new vector<const ContainedObject*>;
12009  }
12010  static void *newArray_vectorlEconstsPContainedObjectmUgR(Long_t nElements, void *p) {
12011  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<const ContainedObject*>[nElements] : new vector<const ContainedObject*>[nElements];
12012  }
12013  // Wrapper around operator delete
12014  static void delete_vectorlEconstsPContainedObjectmUgR(void *p) {
12015  delete ((vector<const ContainedObject*>*)p);
12016  }
12017  static void deleteArray_vectorlEconstsPContainedObjectmUgR(void *p) {
12018  delete [] ((vector<const ContainedObject*>*)p);
12019  }
12020  static void destruct_vectorlEconstsPContainedObjectmUgR(void *p) {
12021  typedef vector<const ContainedObject*> current_t;
12022  ((current_t*)p)->~current_t();
12023  }
12024 } // end of namespace ROOT for class vector<const ContainedObject*>
12025 
12026 namespace ROOT {
12027  static TClass *vectorlESmartReflEObjectContainerBasegRsPgR_Dictionary();
12028  static void vectorlESmartReflEObjectContainerBasegRsPgR_TClassManip(TClass*);
12029  static void *new_vectorlESmartReflEObjectContainerBasegRsPgR(void *p = 0);
12030  static void *newArray_vectorlESmartReflEObjectContainerBasegRsPgR(Long_t size, void *p);
12031  static void delete_vectorlESmartReflEObjectContainerBasegRsPgR(void *p);
12032  static void deleteArray_vectorlESmartReflEObjectContainerBasegRsPgR(void *p);
12033  static void destruct_vectorlESmartReflEObjectContainerBasegRsPgR(void *p);
12034 
12035  // Function generating the singleton type initializer
12036  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<ObjectContainerBase> >*)
12037  {
12038  vector<SmartRef<ObjectContainerBase> > *ptr = 0;
12039  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<ObjectContainerBase> >));
12040  static ::ROOT::TGenericClassInfo
12041  instance("vector<SmartRef<ObjectContainerBase> >", -2, "vector", 214,
12042  typeid(vector<SmartRef<ObjectContainerBase> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12043  &vectorlESmartReflEObjectContainerBasegRsPgR_Dictionary, isa_proxy, 4,
12044  sizeof(vector<SmartRef<ObjectContainerBase> >) );
12045  instance.SetNew(&new_vectorlESmartReflEObjectContainerBasegRsPgR);
12046  instance.SetNewArray(&newArray_vectorlESmartReflEObjectContainerBasegRsPgR);
12047  instance.SetDelete(&delete_vectorlESmartReflEObjectContainerBasegRsPgR);
12048  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEObjectContainerBasegRsPgR);
12049  instance.SetDestructor(&destruct_vectorlESmartReflEObjectContainerBasegRsPgR);
12050  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<ObjectContainerBase> > >()));
12051  return &instance;
12052  }
12053  // Static variable to force the class initialization
12054  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<ObjectContainerBase> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12055 
12056  // Dictionary for non-ClassDef classes
12057  static TClass *vectorlESmartReflEObjectContainerBasegRsPgR_Dictionary() {
12058  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<ObjectContainerBase> >*)0x0)->GetClass();
12059  vectorlESmartReflEObjectContainerBasegRsPgR_TClassManip(theClass);
12060  return theClass;
12061  }
12062 
12063  static void vectorlESmartReflEObjectContainerBasegRsPgR_TClassManip(TClass* ){
12064  }
12065 
12066 } // end of namespace ROOT
12067 
12068 namespace ROOT {
12069  // Wrappers around operator new
12070  static void *new_vectorlESmartReflEObjectContainerBasegRsPgR(void *p) {
12071  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<ObjectContainerBase> > : new vector<SmartRef<ObjectContainerBase> >;
12072  }
12073  static void *newArray_vectorlESmartReflEObjectContainerBasegRsPgR(Long_t nElements, void *p) {
12074  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<ObjectContainerBase> >[nElements] : new vector<SmartRef<ObjectContainerBase> >[nElements];
12075  }
12076  // Wrapper around operator delete
12077  static void delete_vectorlESmartReflEObjectContainerBasegRsPgR(void *p) {
12078  delete ((vector<SmartRef<ObjectContainerBase> >*)p);
12079  }
12080  static void deleteArray_vectorlESmartReflEObjectContainerBasegRsPgR(void *p) {
12081  delete [] ((vector<SmartRef<ObjectContainerBase> >*)p);
12082  }
12083  static void destruct_vectorlESmartReflEObjectContainerBasegRsPgR(void *p) {
12084  typedef vector<SmartRef<ObjectContainerBase> > current_t;
12085  ((current_t*)p)->~current_t();
12086  }
12087 } // end of namespace ROOT for class vector<SmartRef<ObjectContainerBase> >
12088 
12089 namespace ROOT {
12090  static TClass *vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR_Dictionary();
12091  static void vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR_TClassManip(TClass*);
12092  static void *new_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p = 0);
12093  static void *newArray_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(Long_t size, void *p);
12094  static void delete_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p);
12095  static void deleteArray_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p);
12096  static void destruct_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p);
12097 
12098  // Function generating the singleton type initializer
12099  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<KeyedObject<unsigned long> > >*)
12100  {
12101  vector<SmartRef<KeyedObject<unsigned long> > > *ptr = 0;
12102  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<KeyedObject<unsigned long> > >));
12103  static ::ROOT::TGenericClassInfo
12104  instance("vector<SmartRef<KeyedObject<unsigned long> > >", -2, "vector", 214,
12105  typeid(vector<SmartRef<KeyedObject<unsigned long> > >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12106  &vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR_Dictionary, isa_proxy, 4,
12107  sizeof(vector<SmartRef<KeyedObject<unsigned long> > >) );
12108  instance.SetNew(&new_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR);
12109  instance.SetNewArray(&newArray_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR);
12110  instance.SetDelete(&delete_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR);
12111  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR);
12112  instance.SetDestructor(&destruct_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR);
12113  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<KeyedObject<unsigned long> > > >()));
12114  return &instance;
12115  }
12116  // Static variable to force the class initialization
12117  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<unsigned long> > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12118 
12119  // Dictionary for non-ClassDef classes
12120  static TClass *vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR_Dictionary() {
12121  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<unsigned long> > >*)0x0)->GetClass();
12122  vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR_TClassManip(theClass);
12123  return theClass;
12124  }
12125 
12126  static void vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR_TClassManip(TClass* ){
12127  }
12128 
12129 } // end of namespace ROOT
12130 
12131 namespace ROOT {
12132  // Wrappers around operator new
12133  static void *new_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p) {
12134  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<unsigned long> > > : new vector<SmartRef<KeyedObject<unsigned long> > >;
12135  }
12136  static void *newArray_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(Long_t nElements, void *p) {
12137  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<unsigned long> > >[nElements] : new vector<SmartRef<KeyedObject<unsigned long> > >[nElements];
12138  }
12139  // Wrapper around operator delete
12140  static void delete_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p) {
12141  delete ((vector<SmartRef<KeyedObject<unsigned long> > >*)p);
12142  }
12143  static void deleteArray_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p) {
12144  delete [] ((vector<SmartRef<KeyedObject<unsigned long> > >*)p);
12145  }
12146  static void destruct_vectorlESmartReflEKeyedObjectlEunsignedsPlonggRsPgRsPgR(void *p) {
12147  typedef vector<SmartRef<KeyedObject<unsigned long> > > current_t;
12148  ((current_t*)p)->~current_t();
12149  }
12150 } // end of namespace ROOT for class vector<SmartRef<KeyedObject<unsigned long> > >
12151 
12152 namespace ROOT {
12153  static TClass *vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR_Dictionary();
12154  static void vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR_TClassManip(TClass*);
12155  static void *new_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p = 0);
12156  static void *newArray_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(Long_t size, void *p);
12157  static void delete_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p);
12158  static void deleteArray_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p);
12159  static void destruct_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p);
12160 
12161  // Function generating the singleton type initializer
12162  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<KeyedObject<unsigned int> > >*)
12163  {
12164  vector<SmartRef<KeyedObject<unsigned int> > > *ptr = 0;
12165  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<KeyedObject<unsigned int> > >));
12166  static ::ROOT::TGenericClassInfo
12167  instance("vector<SmartRef<KeyedObject<unsigned int> > >", -2, "vector", 214,
12168  typeid(vector<SmartRef<KeyedObject<unsigned int> > >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12169  &vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR_Dictionary, isa_proxy, 4,
12170  sizeof(vector<SmartRef<KeyedObject<unsigned int> > >) );
12171  instance.SetNew(&new_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR);
12172  instance.SetNewArray(&newArray_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR);
12173  instance.SetDelete(&delete_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR);
12174  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR);
12175  instance.SetDestructor(&destruct_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR);
12176  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<KeyedObject<unsigned int> > > >()));
12177  return &instance;
12178  }
12179  // Static variable to force the class initialization
12180  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<unsigned int> > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12181 
12182  // Dictionary for non-ClassDef classes
12183  static TClass *vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR_Dictionary() {
12184  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<unsigned int> > >*)0x0)->GetClass();
12185  vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR_TClassManip(theClass);
12186  return theClass;
12187  }
12188 
12189  static void vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR_TClassManip(TClass* ){
12190  }
12191 
12192 } // end of namespace ROOT
12193 
12194 namespace ROOT {
12195  // Wrappers around operator new
12196  static void *new_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p) {
12197  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<unsigned int> > > : new vector<SmartRef<KeyedObject<unsigned int> > >;
12198  }
12199  static void *newArray_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(Long_t nElements, void *p) {
12200  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<unsigned int> > >[nElements] : new vector<SmartRef<KeyedObject<unsigned int> > >[nElements];
12201  }
12202  // Wrapper around operator delete
12203  static void delete_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p) {
12204  delete ((vector<SmartRef<KeyedObject<unsigned int> > >*)p);
12205  }
12206  static void deleteArray_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p) {
12207  delete [] ((vector<SmartRef<KeyedObject<unsigned int> > >*)p);
12208  }
12209  static void destruct_vectorlESmartReflEKeyedObjectlEunsignedsPintgRsPgRsPgR(void *p) {
12210  typedef vector<SmartRef<KeyedObject<unsigned int> > > current_t;
12211  ((current_t*)p)->~current_t();
12212  }
12213 } // end of namespace ROOT for class vector<SmartRef<KeyedObject<unsigned int> > >
12214 
12215 namespace ROOT {
12216  static TClass *vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR_Dictionary();
12217  static void vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR_TClassManip(TClass*);
12218  static void *new_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p = 0);
12219  static void *newArray_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(Long_t size, void *p);
12220  static void delete_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p);
12221  static void deleteArray_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p);
12222  static void destruct_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p);
12223 
12224  // Function generating the singleton type initializer
12225  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<KeyedObject<long> > >*)
12226  {
12227  vector<SmartRef<KeyedObject<long> > > *ptr = 0;
12228  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<KeyedObject<long> > >));
12229  static ::ROOT::TGenericClassInfo
12230  instance("vector<SmartRef<KeyedObject<long> > >", -2, "vector", 214,
12231  typeid(vector<SmartRef<KeyedObject<long> > >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12232  &vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR_Dictionary, isa_proxy, 4,
12233  sizeof(vector<SmartRef<KeyedObject<long> > >) );
12234  instance.SetNew(&new_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR);
12235  instance.SetNewArray(&newArray_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR);
12236  instance.SetDelete(&delete_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR);
12237  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR);
12238  instance.SetDestructor(&destruct_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR);
12239  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<KeyedObject<long> > > >()));
12240  return &instance;
12241  }
12242  // Static variable to force the class initialization
12243  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<long> > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12244 
12245  // Dictionary for non-ClassDef classes
12246  static TClass *vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR_Dictionary() {
12247  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<long> > >*)0x0)->GetClass();
12248  vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR_TClassManip(theClass);
12249  return theClass;
12250  }
12251 
12252  static void vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR_TClassManip(TClass* ){
12253  }
12254 
12255 } // end of namespace ROOT
12256 
12257 namespace ROOT {
12258  // Wrappers around operator new
12259  static void *new_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p) {
12260  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<long> > > : new vector<SmartRef<KeyedObject<long> > >;
12261  }
12262  static void *newArray_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(Long_t nElements, void *p) {
12263  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<long> > >[nElements] : new vector<SmartRef<KeyedObject<long> > >[nElements];
12264  }
12265  // Wrapper around operator delete
12266  static void delete_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p) {
12267  delete ((vector<SmartRef<KeyedObject<long> > >*)p);
12268  }
12269  static void deleteArray_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p) {
12270  delete [] ((vector<SmartRef<KeyedObject<long> > >*)p);
12271  }
12272  static void destruct_vectorlESmartReflEKeyedObjectlElonggRsPgRsPgR(void *p) {
12273  typedef vector<SmartRef<KeyedObject<long> > > current_t;
12274  ((current_t*)p)->~current_t();
12275  }
12276 } // end of namespace ROOT for class vector<SmartRef<KeyedObject<long> > >
12277 
12278 namespace ROOT {
12279  static TClass *vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR_Dictionary();
12280  static void vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR_TClassManip(TClass*);
12281  static void *new_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p = 0);
12282  static void *newArray_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(Long_t size, void *p);
12283  static void delete_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p);
12284  static void deleteArray_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p);
12285  static void destruct_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p);
12286 
12287  // Function generating the singleton type initializer
12288  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<KeyedObject<int> > >*)
12289  {
12290  vector<SmartRef<KeyedObject<int> > > *ptr = 0;
12291  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<KeyedObject<int> > >));
12292  static ::ROOT::TGenericClassInfo
12293  instance("vector<SmartRef<KeyedObject<int> > >", -2, "vector", 214,
12294  typeid(vector<SmartRef<KeyedObject<int> > >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12295  &vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR_Dictionary, isa_proxy, 4,
12296  sizeof(vector<SmartRef<KeyedObject<int> > >) );
12297  instance.SetNew(&new_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR);
12298  instance.SetNewArray(&newArray_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR);
12299  instance.SetDelete(&delete_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR);
12300  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR);
12301  instance.SetDestructor(&destruct_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR);
12302  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<KeyedObject<int> > > >()));
12303  return &instance;
12304  }
12305  // Static variable to force the class initialization
12306  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<int> > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12307 
12308  // Dictionary for non-ClassDef classes
12309  static TClass *vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR_Dictionary() {
12310  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<KeyedObject<int> > >*)0x0)->GetClass();
12311  vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR_TClassManip(theClass);
12312  return theClass;
12313  }
12314 
12315  static void vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR_TClassManip(TClass* ){
12316  }
12317 
12318 } // end of namespace ROOT
12319 
12320 namespace ROOT {
12321  // Wrappers around operator new
12322  static void *new_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p) {
12323  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<int> > > : new vector<SmartRef<KeyedObject<int> > >;
12324  }
12325  static void *newArray_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(Long_t nElements, void *p) {
12326  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<KeyedObject<int> > >[nElements] : new vector<SmartRef<KeyedObject<int> > >[nElements];
12327  }
12328  // Wrapper around operator delete
12329  static void delete_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p) {
12330  delete ((vector<SmartRef<KeyedObject<int> > >*)p);
12331  }
12332  static void deleteArray_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p) {
12333  delete [] ((vector<SmartRef<KeyedObject<int> > >*)p);
12334  }
12335  static void destruct_vectorlESmartReflEKeyedObjectlEintgRsPgRsPgR(void *p) {
12336  typedef vector<SmartRef<KeyedObject<int> > > current_t;
12337  ((current_t*)p)->~current_t();
12338  }
12339 } // end of namespace ROOT for class vector<SmartRef<KeyedObject<int> > >
12340 
12341 namespace ROOT {
12342  static TClass *vectorlESmartReflEDataObjectgRsPgR_Dictionary();
12343  static void vectorlESmartReflEDataObjectgRsPgR_TClassManip(TClass*);
12344  static void *new_vectorlESmartReflEDataObjectgRsPgR(void *p = 0);
12345  static void *newArray_vectorlESmartReflEDataObjectgRsPgR(Long_t size, void *p);
12346  static void delete_vectorlESmartReflEDataObjectgRsPgR(void *p);
12347  static void deleteArray_vectorlESmartReflEDataObjectgRsPgR(void *p);
12348  static void destruct_vectorlESmartReflEDataObjectgRsPgR(void *p);
12349 
12350  // Function generating the singleton type initializer
12351  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<DataObject> >*)
12352  {
12353  vector<SmartRef<DataObject> > *ptr = 0;
12354  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<DataObject> >));
12355  static ::ROOT::TGenericClassInfo
12356  instance("vector<SmartRef<DataObject> >", -2, "vector", 214,
12357  typeid(vector<SmartRef<DataObject> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12358  &vectorlESmartReflEDataObjectgRsPgR_Dictionary, isa_proxy, 4,
12359  sizeof(vector<SmartRef<DataObject> >) );
12360  instance.SetNew(&new_vectorlESmartReflEDataObjectgRsPgR);
12361  instance.SetNewArray(&newArray_vectorlESmartReflEDataObjectgRsPgR);
12362  instance.SetDelete(&delete_vectorlESmartReflEDataObjectgRsPgR);
12363  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEDataObjectgRsPgR);
12364  instance.SetDestructor(&destruct_vectorlESmartReflEDataObjectgRsPgR);
12365  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<DataObject> > >()));
12366  return &instance;
12367  }
12368  // Static variable to force the class initialization
12369  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<DataObject> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12370 
12371  // Dictionary for non-ClassDef classes
12372  static TClass *vectorlESmartReflEDataObjectgRsPgR_Dictionary() {
12373  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<DataObject> >*)0x0)->GetClass();
12374  vectorlESmartReflEDataObjectgRsPgR_TClassManip(theClass);
12375  return theClass;
12376  }
12377 
12378  static void vectorlESmartReflEDataObjectgRsPgR_TClassManip(TClass* ){
12379  }
12380 
12381 } // end of namespace ROOT
12382 
12383 namespace ROOT {
12384  // Wrappers around operator new
12385  static void *new_vectorlESmartReflEDataObjectgRsPgR(void *p) {
12386  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<DataObject> > : new vector<SmartRef<DataObject> >;
12387  }
12388  static void *newArray_vectorlESmartReflEDataObjectgRsPgR(Long_t nElements, void *p) {
12389  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<DataObject> >[nElements] : new vector<SmartRef<DataObject> >[nElements];
12390  }
12391  // Wrapper around operator delete
12392  static void delete_vectorlESmartReflEDataObjectgRsPgR(void *p) {
12393  delete ((vector<SmartRef<DataObject> >*)p);
12394  }
12395  static void deleteArray_vectorlESmartReflEDataObjectgRsPgR(void *p) {
12396  delete [] ((vector<SmartRef<DataObject> >*)p);
12397  }
12398  static void destruct_vectorlESmartReflEDataObjectgRsPgR(void *p) {
12399  typedef vector<SmartRef<DataObject> > current_t;
12400  ((current_t*)p)->~current_t();
12401  }
12402 } // end of namespace ROOT for class vector<SmartRef<DataObject> >
12403 
12404 namespace ROOT {
12405  static TClass *vectorlESmartReflEContainedObjectgRsPgR_Dictionary();
12406  static void vectorlESmartReflEContainedObjectgRsPgR_TClassManip(TClass*);
12407  static void *new_vectorlESmartReflEContainedObjectgRsPgR(void *p = 0);
12408  static void *newArray_vectorlESmartReflEContainedObjectgRsPgR(Long_t size, void *p);
12409  static void delete_vectorlESmartReflEContainedObjectgRsPgR(void *p);
12410  static void deleteArray_vectorlESmartReflEContainedObjectgRsPgR(void *p);
12411  static void destruct_vectorlESmartReflEContainedObjectgRsPgR(void *p);
12412 
12413  // Function generating the singleton type initializer
12414  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SmartRef<ContainedObject> >*)
12415  {
12416  vector<SmartRef<ContainedObject> > *ptr = 0;
12417  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SmartRef<ContainedObject> >));
12418  static ::ROOT::TGenericClassInfo
12419  instance("vector<SmartRef<ContainedObject> >", -2, "vector", 214,
12420  typeid(vector<SmartRef<ContainedObject> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12421  &vectorlESmartReflEContainedObjectgRsPgR_Dictionary, isa_proxy, 4,
12422  sizeof(vector<SmartRef<ContainedObject> >) );
12423  instance.SetNew(&new_vectorlESmartReflEContainedObjectgRsPgR);
12424  instance.SetNewArray(&newArray_vectorlESmartReflEContainedObjectgRsPgR);
12425  instance.SetDelete(&delete_vectorlESmartReflEContainedObjectgRsPgR);
12426  instance.SetDeleteArray(&deleteArray_vectorlESmartReflEContainedObjectgRsPgR);
12427  instance.SetDestructor(&destruct_vectorlESmartReflEContainedObjectgRsPgR);
12428  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SmartRef<ContainedObject> > >()));
12429  return &instance;
12430  }
12431  // Static variable to force the class initialization
12432  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<SmartRef<ContainedObject> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12433 
12434  // Dictionary for non-ClassDef classes
12435  static TClass *vectorlESmartReflEContainedObjectgRsPgR_Dictionary() {
12436  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<SmartRef<ContainedObject> >*)0x0)->GetClass();
12437  vectorlESmartReflEContainedObjectgRsPgR_TClassManip(theClass);
12438  return theClass;
12439  }
12440 
12441  static void vectorlESmartReflEContainedObjectgRsPgR_TClassManip(TClass* ){
12442  }
12443 
12444 } // end of namespace ROOT
12445 
12446 namespace ROOT {
12447  // Wrappers around operator new
12448  static void *new_vectorlESmartReflEContainedObjectgRsPgR(void *p) {
12449  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<ContainedObject> > : new vector<SmartRef<ContainedObject> >;
12450  }
12451  static void *newArray_vectorlESmartReflEContainedObjectgRsPgR(Long_t nElements, void *p) {
12452  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SmartRef<ContainedObject> >[nElements] : new vector<SmartRef<ContainedObject> >[nElements];
12453  }
12454  // Wrapper around operator delete
12455  static void delete_vectorlESmartReflEContainedObjectgRsPgR(void *p) {
12456  delete ((vector<SmartRef<ContainedObject> >*)p);
12457  }
12458  static void deleteArray_vectorlESmartReflEContainedObjectgRsPgR(void *p) {
12459  delete [] ((vector<SmartRef<ContainedObject> >*)p);
12460  }
12461  static void destruct_vectorlESmartReflEContainedObjectgRsPgR(void *p) {
12462  typedef vector<SmartRef<ContainedObject> > current_t;
12463  ((current_t*)p)->~current_t();
12464  }
12465 } // end of namespace ROOT for class vector<SmartRef<ContainedObject> >
12466 
12467 namespace ROOT {
12468  static TClass *vectorlELinkManagercLcLLinkmUgR_Dictionary();
12469  static void vectorlELinkManagercLcLLinkmUgR_TClassManip(TClass*);
12470  static void *new_vectorlELinkManagercLcLLinkmUgR(void *p = 0);
12471  static void *newArray_vectorlELinkManagercLcLLinkmUgR(Long_t size, void *p);
12472  static void delete_vectorlELinkManagercLcLLinkmUgR(void *p);
12473  static void deleteArray_vectorlELinkManagercLcLLinkmUgR(void *p);
12474  static void destruct_vectorlELinkManagercLcLLinkmUgR(void *p);
12475 
12476  // Function generating the singleton type initializer
12477  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<LinkManager::Link*>*)
12478  {
12479  vector<LinkManager::Link*> *ptr = 0;
12480  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<LinkManager::Link*>));
12481  static ::ROOT::TGenericClassInfo
12482  instance("vector<LinkManager::Link*>", -2, "vector", 214,
12483  typeid(vector<LinkManager::Link*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12484  &vectorlELinkManagercLcLLinkmUgR_Dictionary, isa_proxy, 4,
12485  sizeof(vector<LinkManager::Link*>) );
12486  instance.SetNew(&new_vectorlELinkManagercLcLLinkmUgR);
12487  instance.SetNewArray(&newArray_vectorlELinkManagercLcLLinkmUgR);
12488  instance.SetDelete(&delete_vectorlELinkManagercLcLLinkmUgR);
12489  instance.SetDeleteArray(&deleteArray_vectorlELinkManagercLcLLinkmUgR);
12490  instance.SetDestructor(&destruct_vectorlELinkManagercLcLLinkmUgR);
12491  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<LinkManager::Link*> >()));
12492  return &instance;
12493  }
12494  // Static variable to force the class initialization
12495  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<LinkManager::Link*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12496 
12497  // Dictionary for non-ClassDef classes
12498  static TClass *vectorlELinkManagercLcLLinkmUgR_Dictionary() {
12499  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<LinkManager::Link*>*)0x0)->GetClass();
12500  vectorlELinkManagercLcLLinkmUgR_TClassManip(theClass);
12501  return theClass;
12502  }
12503 
12504  static void vectorlELinkManagercLcLLinkmUgR_TClassManip(TClass* ){
12505  }
12506 
12507 } // end of namespace ROOT
12508 
12509 namespace ROOT {
12510  // Wrappers around operator new
12511  static void *new_vectorlELinkManagercLcLLinkmUgR(void *p) {
12512  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<LinkManager::Link*> : new vector<LinkManager::Link*>;
12513  }
12514  static void *newArray_vectorlELinkManagercLcLLinkmUgR(Long_t nElements, void *p) {
12515  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<LinkManager::Link*>[nElements] : new vector<LinkManager::Link*>[nElements];
12516  }
12517  // Wrapper around operator delete
12518  static void delete_vectorlELinkManagercLcLLinkmUgR(void *p) {
12519  delete ((vector<LinkManager::Link*>*)p);
12520  }
12521  static void deleteArray_vectorlELinkManagercLcLLinkmUgR(void *p) {
12522  delete [] ((vector<LinkManager::Link*>*)p);
12523  }
12524  static void destruct_vectorlELinkManagercLcLLinkmUgR(void *p) {
12525  typedef vector<LinkManager::Link*> current_t;
12526  ((current_t*)p)->~current_t();
12527  }
12528 } // end of namespace ROOT for class vector<LinkManager::Link*>
12529 
12530 namespace ROOT {
12531  static TClass *vectorlEDataObjectmUgR_Dictionary();
12532  static void vectorlEDataObjectmUgR_TClassManip(TClass*);
12533  static void *new_vectorlEDataObjectmUgR(void *p = 0);
12534  static void *newArray_vectorlEDataObjectmUgR(Long_t size, void *p);
12535  static void delete_vectorlEDataObjectmUgR(void *p);
12536  static void deleteArray_vectorlEDataObjectmUgR(void *p);
12537  static void destruct_vectorlEDataObjectmUgR(void *p);
12538 
12539  // Function generating the singleton type initializer
12540  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<DataObject*>*)
12541  {
12542  vector<DataObject*> *ptr = 0;
12543  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<DataObject*>));
12544  static ::ROOT::TGenericClassInfo
12545  instance("vector<DataObject*>", -2, "vector", 214,
12546  typeid(vector<DataObject*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12547  &vectorlEDataObjectmUgR_Dictionary, isa_proxy, 4,
12548  sizeof(vector<DataObject*>) );
12549  instance.SetNew(&new_vectorlEDataObjectmUgR);
12550  instance.SetNewArray(&newArray_vectorlEDataObjectmUgR);
12551  instance.SetDelete(&delete_vectorlEDataObjectmUgR);
12552  instance.SetDeleteArray(&deleteArray_vectorlEDataObjectmUgR);
12553  instance.SetDestructor(&destruct_vectorlEDataObjectmUgR);
12554  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<DataObject*> >()));
12555  return &instance;
12556  }
12557  // Static variable to force the class initialization
12558  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<DataObject*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12559 
12560  // Dictionary for non-ClassDef classes
12561  static TClass *vectorlEDataObjectmUgR_Dictionary() {
12562  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<DataObject*>*)0x0)->GetClass();
12563  vectorlEDataObjectmUgR_TClassManip(theClass);
12564  return theClass;
12565  }
12566 
12567  static void vectorlEDataObjectmUgR_TClassManip(TClass* ){
12568  }
12569 
12570 } // end of namespace ROOT
12571 
12572 namespace ROOT {
12573  // Wrappers around operator new
12574  static void *new_vectorlEDataObjectmUgR(void *p) {
12575  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<DataObject*> : new vector<DataObject*>;
12576  }
12577  static void *newArray_vectorlEDataObjectmUgR(Long_t nElements, void *p) {
12578  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<DataObject*>[nElements] : new vector<DataObject*>[nElements];
12579  }
12580  // Wrapper around operator delete
12581  static void delete_vectorlEDataObjectmUgR(void *p) {
12582  delete ((vector<DataObject*>*)p);
12583  }
12584  static void deleteArray_vectorlEDataObjectmUgR(void *p) {
12585  delete [] ((vector<DataObject*>*)p);
12586  }
12587  static void destruct_vectorlEDataObjectmUgR(void *p) {
12588  typedef vector<DataObject*> current_t;
12589  ((current_t*)p)->~current_t();
12590  }
12591 } // end of namespace ROOT for class vector<DataObject*>
12592 
12593 namespace ROOT {
12594  static TClass *vectorlEContainedObjectmUgR_Dictionary();
12595  static void vectorlEContainedObjectmUgR_TClassManip(TClass*);
12596  static void *new_vectorlEContainedObjectmUgR(void *p = 0);
12597  static void *newArray_vectorlEContainedObjectmUgR(Long_t size, void *p);
12598  static void delete_vectorlEContainedObjectmUgR(void *p);
12599  static void deleteArray_vectorlEContainedObjectmUgR(void *p);
12600  static void destruct_vectorlEContainedObjectmUgR(void *p);
12601 
12602  // Function generating the singleton type initializer
12603  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<ContainedObject*>*)
12604  {
12605  vector<ContainedObject*> *ptr = 0;
12606  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<ContainedObject*>));
12607  static ::ROOT::TGenericClassInfo
12608  instance("vector<ContainedObject*>", -2, "vector", 214,
12609  typeid(vector<ContainedObject*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
12610  &vectorlEContainedObjectmUgR_Dictionary, isa_proxy, 4,
12611  sizeof(vector<ContainedObject*>) );
12612  instance.SetNew(&new_vectorlEContainedObjectmUgR);
12613  instance.SetNewArray(&newArray_vectorlEContainedObjectmUgR);
12614  instance.SetDelete(&delete_vectorlEContainedObjectmUgR);
12615  instance.SetDeleteArray(&deleteArray_vectorlEContainedObjectmUgR);
12616  instance.SetDestructor(&destruct_vectorlEContainedObjectmUgR);
12617  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<ContainedObject*> >()));
12618  return &instance;
12619  }
12620  // Static variable to force the class initialization
12621  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<ContainedObject*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
12622 
12623  // Dictionary for non-ClassDef classes
12624  static TClass *vectorlEContainedObjectmUgR_Dictionary() {
12625  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<ContainedObject*>*)0x0)->GetClass();
12626  vectorlEContainedObjectmUgR_TClassManip(theClass);
12627  return theClass;
12628  }
12629 
12630  static void vectorlEContainedObjectmUgR_TClassManip(TClass* ){
12631  }
12632 
12633 } // end of namespace ROOT
12634 
12635 namespace ROOT {
12636  // Wrappers around operator new
12637  static void *new_vectorlEContainedObjectmUgR(void *p) {
12638  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<ContainedObject*> : new vector<ContainedObject*>;
12639  }
12640  static void *newArray_vectorlEContainedObjectmUgR(Long_t nElements, void *p) {
12641  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<ContainedObject*>[nElements] : new vector<ContainedObject*>[nElements];
12642  }
12643  // Wrapper around operator delete
12644  static void delete_vectorlEContainedObjectmUgR(void *p) {
12645  delete ((vector<ContainedObject*>*)p);
12646  }
12647  static void deleteArray_vectorlEContainedObjectmUgR(void *p) {
12648  delete [] ((vector<ContainedObject*>*)p);
12649  }
12650  static void destruct_vectorlEContainedObjectmUgR(void *p) {
12651  typedef vector<ContainedObject*> current_t;
12652  ((current_t*)p)->~current_t();
12653  }
12654 } // end of namespace ROOT for class vector<ContainedObject*>
12655 
12656 namespace {
12657  void TriggerDictionaryInitialization_GaudiKernelDict_Impl() {
12658  static const char* headers[] = {
12659 0 };
12660  static const char* includePaths[] = {
12661 "/builds/gaudi/Gaudi/GaudiKernel",
12662 "/builds/gaudi/Gaudi/GaudiPluginService",
12663 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/tbb/2018_U1/x86_64-centos7-gcc62-opt/include",
12664 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/ROOT/6.12.06/x86_64-centos7-gcc62-opt/include",
12665 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/Boost/1.66.0/x86_64-centos7-gcc62-opt/include",
12666 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/CppUnit/1.12.1_p1/x86_64-centos7-gcc62-opt/include",
12667 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/vectorclass/1.30/x86_64-centos7-gcc62-opt",
12668 "/builds/gaudi/Gaudi/build-gcc62/include",
12669 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/rangev3/0.3.0/x86_64-centos7-gcc62-opt/include",
12670 "/cvmfs/sft.cern.ch/lcg/releases/ROOT/6.12.06-51921/x86_64-centos7-gcc62-opt/include",
12671 "/builds/gaudi/Gaudi/build-gcc62/GaudiKernel/",
12672 0
12673  };
12674  static const char* fwdDeclCode = R"DICTFWDDCLS(
12675 #line 1 "GaudiKernelDict dictionary forward declarations' payload"
12676 #pragma clang diagnostic ignored "-Wkeyword-compat"
12677 #pragma clang diagnostic ignored "-Wignored-attributes"
12678 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
12679 extern int __Cling_Autoloading_Map;
12680 class __attribute__((annotate(R"ATTRDUMP(id@@@000000BE-0000-0000-0000-000000000000)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/ContainedObject.h"))) ContainedObject;
12681 namespace std{template <typename _Tp> class __attribute__((annotate("$clingAutoload$bits/allocator.h"))) __attribute__((annotate("$clingAutoload$string"))) allocator;
12682 }
12683 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;
12684 template <class TYPE> class __attribute__((annotate("$clingAutoload$GaudiKernel/SmartRef.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) SmartRef;
12685 
12686 class __attribute__((annotate("$clingAutoload$GaudiKernel/ObjectContainerBase.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/ContainedObject.h"))) ObjectContainerBase;
12687 template <class KEY> class __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObject.h"))) KeyedObject;
12688 
12689 class __attribute__((annotate("$clingAutoload$GaudiKernel/StatusCode.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) StatusCode;
12690 class __attribute__((annotate("$clingAutoload$GaudiKernel/IInterface.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) InterfaceID;
12691 class __attribute__((annotate("$clingAutoload$GaudiKernel/IInterface.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IInterface;
12692 class __attribute__((annotate("$clingAutoload$GaudiKernel/IMessageSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IMessageSvc;
12693 class __attribute__((annotate("$clingAutoload$GaudiKernel/INamedInterface.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) INamedInterface;
12694 class __attribute__((annotate("$clingAutoload$GaudiKernel/IStateful.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IStateful;
12695 class __attribute__((annotate("$clingAutoload$GaudiKernel/IService.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IService;
12696 template <class TYPE> class __attribute__((annotate("$clingAutoload$GaudiKernel/SmartIF.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) SmartIF;
12697 
12698 class __attribute__((annotate("$clingAutoload$GaudiKernel/ISvcLocator.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) ISvcLocator;
12699 class __attribute__((annotate("$clingAutoload$GaudiKernel/IProperty.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IProperty;
12700 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDataProviderSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IDataProviderSvc;
12701 class __attribute__((annotate("$clingAutoload$GaudiKernel/IToolSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IToolSvc;
12702 class __attribute__((annotate("$clingAutoload$GaudiKernel/IMonitorSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IMonitorSvc;
12703 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAuditorSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IAuditorSvc;
12704 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgContextSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IAlgContextSvc;
12705 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgorithm.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IAlgorithm;
12706 class __attribute__((annotate("$clingAutoload$GaudiKernel/IConversionSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IConversionSvc;
12707 class __attribute__((annotate("$clingAutoload$GaudiKernel/IRndmGen.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IRndmGen;
12708 class __attribute__((annotate("$clingAutoload$GaudiKernel/IChronoStatSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IChronoStatSvc;
12709 class __attribute__((annotate("$clingAutoload$GaudiKernel/IHistogramSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IHistogramSvc;
12710 class __attribute__((annotate("$clingAutoload$GaudiKernel/INTupleSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) INTupleSvc;
12711 class __attribute__((annotate("$clingAutoload$GaudiKernel/IRndmGenSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IRndmGenSvc;
12712 class __attribute__((annotate("$clingAutoload$GaudiKernel/IExceptionSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IExceptionSvc;
12713 class __attribute__((annotate("$clingAutoload$GaudiKernel/ITimelineSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) ITimelineSvc;
12714 class __attribute__((annotate("$clingAutoload$GaudiKernel/IHiveWhiteBoard.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IHiveWhiteBoard;
12715 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgExecStateSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IAlgExecStateSvc;
12716 class __attribute__((annotate("$clingAutoload$GaudiKernel/ISvcManager.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) ISvcManager;
12717 class __attribute__((annotate("$clingAutoload$GaudiKernel/IIncidentSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataStreamTool.h"))) IIncidentSvc;
12718 class __attribute__((annotate("$clingAutoload$GaudiKernel/IEvtSelector.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataStreamTool.h"))) IEvtSelector;
12719 class __attribute__((annotate("$clingAutoload$GaudiKernel/ISelectStatement.h"))) ISelectStatement;
12720 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgTool.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IAlgTool;
12721 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAuditor.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) IAuditor;
12722 namespace Gaudi{namespace Details{class __attribute__((annotate("$clingAutoload$GaudiKernel/Property.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) PropertyBase;}}
12723 class __attribute__((annotate("$clingAutoload$GaudiKernel/Property.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) GaudiHandleProperty;
12724 class __attribute__((annotate("$clingAutoload$GaudiKernel/Property.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) GaudiHandleArrayProperty;
12725 class __attribute__((annotate(R"ATTRDUMP(pattern@@@DataObjectHandle*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataObjectHandleProperty.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) DataObjectHandleProperty;
12726 class __attribute__((annotate("$clingAutoload$GaudiKernel/GaudiHandle.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) GaudiHandleInfo;
12727 class __attribute__((annotate("$clingAutoload$GaudiKernel/GaudiHandle.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) GaudiHandleBase;
12728 class __attribute__((annotate("$clingAutoload$GaudiKernel/GaudiHandle.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) GaudiHandleArrayBase;
12729 class __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) AlgTool;
12730 class __attribute__((annotate("$clingAutoload$GaudiKernel/IChronoSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IChronoSvc;
12731 class __attribute__((annotate("$clingAutoload$GaudiKernel/IStatSvc.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IStatSvc;
12732 class __attribute__((annotate("$clingAutoload$GaudiKernel/IConverter.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IConverter;
12733 class __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) Algorithm;
12734 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDataStreamTool.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataStreamTool.h"))) IDataStreamTool;
12735 class __attribute__((annotate("$clingAutoload$GaudiKernel/IOpaqueAddress.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataStreamTool.h"))) IOpaqueAddress;
12736 class __attribute__((annotate("$clingAutoload$GaudiKernel/Incident.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataStreamTool.h"))) Incident;
12737 class __attribute__((annotate("$clingAutoload$GaudiKernel/Service.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataStreamTool.h"))) Service;
12738 class __attribute__((annotate("$clingAutoload$GaudiKernel/GenericAddress.h"))) GenericAddress;
12739 namespace Containers{struct __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObjectManager.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObject.h"))) map;}
12740 namespace Containers{template <class SETUP> class __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObjectManager.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObject.h"))) KeyedObjectManager;
12741 }
12742 namespace Containers{struct __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObjectManager.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObject.h"))) hashmap;}
12743 namespace Containers{struct __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObjectManager.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObject.h"))) vector;}
12744 namespace Containers{struct __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObjectManager.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/KeyedObject.h"))) array;}
12745 class __attribute__((annotate("$clingAutoload$GaudiKernel/LinkManager.h"))) LinkManager;
12746 class __attribute__((annotate("$clingAutoload$GaudiKernel/SmartRefBase.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) SmartRefBase;
12747 class __attribute__((annotate("$clingAutoload$GaudiKernel/INTuple.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) INTuple;
12748 class __attribute__((annotate(R"ATTRDUMP(pattern@@@SmartData*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/SmartDataObjectPtr.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) SmartDataObjectPtr;
12749 template <class TYPE> class __attribute__((annotate("$clingAutoload$GaudiKernel/SmartDataPtr.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) SmartDataPtr;
12750 
12751 namespace NTuple{template <class TYP> class __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) Item;
12752 }
12753 namespace NTuple{template <class TYP> class __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) Array;
12754 }
12755 namespace NTuple{template <class TYP> class __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) Matrix;
12756 }
12757 namespace NTuple{struct __attribute__((annotate(R"ATTRDUMP(id@@@00000029-0000-0000-0000-000000000000)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) Directory;}
12758 namespace NTuple{class __attribute__((annotate(R"ATTRDUMP(id@@@00000028-0000-0000-0000-000000000000)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTuple.h"))) File;}
12759 namespace NTuple{class __attribute__((annotate(R"ATTRDUMP(id@@@0000002B-0000-0000-0000-000000000000)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTupleImplementation.h"))) ColumnWiseTuple;}
12760 namespace NTuple{class __attribute__((annotate(R"ATTRDUMP(id@@@0000002A-0000-0000-0000-000000000000)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/NTupleImplementation.h"))) RowWiseTuple;}
12761 class __attribute__((annotate("$clingAutoload$GaudiKernel/IRegistry.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RegistryEntry.h"))) IRegistry;
12762 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Gauss;}
12763 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Exponential;}
12764 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Chi2;}
12765 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) BreitWigner;}
12766 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Landau;}
12767 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) BreitWignerCutOff;}
12768 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) StudentT;}
12769 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Gamma;}
12770 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Poisson;}
12771 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Binomial;}
12772 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Flat;}
12773 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Bit;}
12774 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) DefinedPdf;}
12775 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) GaussianTail;}
12776 namespace Rndm{class __attribute__((annotate(R"ATTRDUMP(pattern@@@Rndm::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/RndmGenerators.h"))) Numbers;}
12777 template <class TYPE> class __attribute__((annotate("$clingAutoload$GaudiKernel/SmartRefVector.h"))) SmartRefVector;
12778 
12779 namespace Gaudi{class __attribute__((annotate("$clingAutoload$GaudiKernel/Time.h"))) Time;}
12780 class __attribute__((annotate(R"ATTRDUMP(pattern@@@DataObjectHandle*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataObjectHandleBase.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/DataObjectHandle.h"))) DataObjectHandleBase;
12781 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAddressCreator.h"))) IAddressCreator;
12782 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgManager.h"))) IAlgManager;
12783 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAppMgrUI.h"))) IAppMgrUI;
12784 class __attribute__((annotate("$clingAutoload$GaudiKernel/IClassInfo.h"))) IClassInfo;
12785 class __attribute__((annotate("$clingAutoload$GaudiKernel/IClassManager.h"))) IClassManager;
12786 class __attribute__((annotate("$clingAutoload$GaudiKernel/ICounterSummarySvc.h"))) ICounterSummarySvc;
12787 struct __attribute__((annotate("$clingAutoload$GaudiKernel/IDataManagerSvc.h"))) IDataManagerSvc;
12788 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDataSourceMgr.h"))) IDataSourceMgr;
12789 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDataStoreAgent.h"))) IDataStoreAgent;
12790 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDataStoreLeaves.h"))) IDataStoreLeaves;
12791 class __attribute__((annotate("$clingAutoload$GaudiKernel/IDetDataSvc.h"))) IDetDataSvc;
12792 class __attribute__((annotate("$clingAutoload$GaudiKernel/IEventProcessor.h"))) IEventProcessor;
12793 class __attribute__((annotate("$clingAutoload$GaudiKernel/IEventTimeDecoder.h"))) IEventTimeDecoder;
12794 class __attribute__((annotate("$clingAutoload$GaudiKernel/IHistorySvc.h"))) IHistorySvc;
12795 class __attribute__((annotate("$clingAutoload$GaudiKernel/IIncidentListener.h"))) IIncidentListener;
12796 class __attribute__((annotate("$clingAutoload$GaudiKernel/IInspectable.h"))) IInspectable;
12797 class __attribute__((annotate("$clingAutoload$GaudiKernel/IInspector.h"))) IInspector;
12798 class __attribute__((annotate("$clingAutoload$GaudiKernel/IJobOptionsSvc.h"))) IJobOptionsSvc;
12799 class __attribute__((annotate("$clingAutoload$GaudiKernel/IMagneticFieldSvc.h"))) IMagneticFieldSvc;
12800 class __attribute__((annotate("$clingAutoload$GaudiKernel/IPartPropSvc.h"))) IPartPropSvc;
12801 class __attribute__((annotate("$clingAutoload$GaudiKernel/IParticlePropertySvc.h"))) IParticlePropertySvc;
12802 class __attribute__((annotate("$clingAutoload$GaudiKernel/IPartitionControl.h"))) IPartitionControl;
12803 class __attribute__((annotate("$clingAutoload$GaudiKernel/IPersistencySvc.h"))) IPersistencySvc;
12804 class __attribute__((annotate("$clingAutoload$GaudiKernel/IRndmEngine.h"))) IRndmEngine;
12805 class __attribute__((annotate("$clingAutoload$GaudiKernel/IRunable.h"))) IRunable;
12806 class __attribute__((annotate("$clingAutoload$GaudiKernel/ISerialize.h"))) ISerialize;
12807 class __attribute__((annotate("$clingAutoload$GaudiKernel/IStagerSvc.h"))) IStagerSvc;
12808 class __attribute__((annotate("$clingAutoload$GaudiKernel/IStatusCodeSvc.h"))) IStatusCodeSvc;
12809 class __attribute__((annotate("$clingAutoload$GaudiKernel/ITHistSvc.h"))) ITHistSvc;
12810 class __attribute__((annotate("$clingAutoload$GaudiKernel/IUpdateManagerSvc.h"))) IUpdateManagerSvc;
12811 class __attribute__((annotate("$clingAutoload$GaudiKernel/IUpdateable.h"))) IUpdateable;
12812 class __attribute__((annotate("$clingAutoload$GaudiKernel/IValidity.h"))) IValidity;
12813 )DICTFWDDCLS";
12814  static const char* payloadCode = R"DICTPAYLOAD(
12815 #line 1 "GaudiKernelDict dictionary payload"
12816 #ifdef _Instantiations
12817  #undef _Instantiations
12818 #endif
12819 
12820 #ifndef G__VECTOR_HAS_CLASS_ITERATOR
12821  #define G__VECTOR_HAS_CLASS_ITERATOR 1
12822 #endif
12823 #ifndef _Instantiations
12824  #define _Instantiations GaudiKernel_Instantiations
12825 #endif
12826 #ifndef _GNU_SOURCE
12827  #define _GNU_SOURCE 1
12828 #endif
12829 #ifndef unix
12830  #define unix 1
12831 #endif
12832 #ifndef f2cFortran
12833  #define f2cFortran 1
12834 #endif
12835 #ifndef linux
12836  #define linux 1
12837 #endif
12838 #ifndef GAUDI_V20_COMPAT
12839  #define GAUDI_V20_COMPAT 1
12840 #endif
12841 #ifndef BOOST_FILESYSTEM_VERSION
12842  #define BOOST_FILESYSTEM_VERSION 3
12843 #endif
12844 #ifndef BOOST_SPIRIT_USE_PHOENIX_V3
12845  #define BOOST_SPIRIT_USE_PHOENIX_V3 1
12846 #endif
12847 #ifndef PACKAGE_NAME
12848  #define PACKAGE_NAME "GaudiKernel"
12849 #endif
12850 #ifndef PACKAGE_VERSION
12851  #define PACKAGE_VERSION "v30r3"
12852 #endif
12853 #ifndef NDEBUG
12854  #define NDEBUG 1
12855 #endif
12856 
12857 #define _BACKWARD_BACKWARD_WARNING_H
12858 #define ALLOW_ALL_TYPES
12859 #include <cstdlib>
12860 #include <vector>
12861 
12862 #include "GaudiKernel/AlgTool.h"
12863 #include "GaudiKernel/Algorithm.h"
12864 #include "GaudiKernel/Bootstrap.h"
12865 #include "GaudiKernel/ContainedObject.h"
12866 #include "GaudiKernel/DataObject.h"
12867 #include "GaudiKernel/DataStreamTool.h"
12868 #include "GaudiKernel/Debugger.h"
12869 #include "GaudiKernel/Environment.h"
12870 #include "GaudiKernel/EventSelectorDataStream.h"
12871 #include "GaudiKernel/GaudiHandle.h"
12872 #include "GaudiKernel/GenericAddress.h"
12873 #include "GaudiKernel/KeyedObject.h"
12874 #include "GaudiKernel/LinkManager.h"
12875 #include "GaudiKernel/Memory.h"
12876 #include "GaudiKernel/NTuple.h"
12877 #include "GaudiKernel/NTupleImplementation.h"
12878 #include "GaudiKernel/ObjectVector.h"
12879 #include "GaudiKernel/Property.h"
12880 #include "GaudiKernel/RegistryEntry.h"
12881 #include "GaudiKernel/RndmGenerators.h"
12882 #include "GaudiKernel/Service.h"
12883 #include "GaudiKernel/SmartDataPtr.h"
12884 #include "GaudiKernel/SmartRefVector.h"
12885 #include "GaudiKernel/System.h"
12886 #include "GaudiKernel/Time.h"
12887 
12888 #include "GaudiKernel/DataObjectHandle.h"
12889 #include "GaudiKernel/IAddressCreator.h"
12890 #include "GaudiKernel/IAlgContextSvc.h"
12891 #include "GaudiKernel/IAlgManager.h"
12892 #include "GaudiKernel/IAlgTool.h"
12893 #include "GaudiKernel/IAlgorithm.h"
12894 #include "GaudiKernel/IAppMgrUI.h"
12895 #include "GaudiKernel/IAuditor.h"
12896 #include "GaudiKernel/IAuditorSvc.h"
12897 #include "GaudiKernel/IChronoStatSvc.h"
12898 #include "GaudiKernel/IClassInfo.h"
12899 #include "GaudiKernel/IClassManager.h"
12900 #include "GaudiKernel/IConversionSvc.h"
12901 #include "GaudiKernel/IConverter.h"
12902 #include "GaudiKernel/ICounterSummarySvc.h"
12903 #include "GaudiKernel/IDataManagerSvc.h"
12904 #include "GaudiKernel/IDataProviderSvc.h"
12905 #include "GaudiKernel/IDataSelector.h"
12906 #include "GaudiKernel/IDataSourceMgr.h"
12907 #include "GaudiKernel/IDataStoreAgent.h"
12908 #include "GaudiKernel/IDataStoreLeaves.h"
12909 #include "GaudiKernel/IDataStreamTool.h"
12910 #include "GaudiKernel/IDetDataSvc.h"
12911 #include "GaudiKernel/IEventProcessor.h"
12912 #include "GaudiKernel/IEventTimeDecoder.h"
12913 #include "GaudiKernel/IEvtSelector.h"
12914 #include "GaudiKernel/IExceptionSvc.h"
12915 #include "GaudiKernel/IHistogramSvc.h"
12916 #include "GaudiKernel/IHistorySvc.h"
12917 #include "GaudiKernel/IIncidentListener.h"
12918 #include "GaudiKernel/IIncidentSvc.h"
12919 #include "GaudiKernel/IInspectable.h"
12920 #include "GaudiKernel/IInspector.h"
12921 #include "GaudiKernel/IInterface.h"
12922 #include "GaudiKernel/IJobOptionsSvc.h"
12923 #include "GaudiKernel/IMagneticFieldSvc.h"
12924 #include "GaudiKernel/IMessageSvc.h"
12925 #include "GaudiKernel/IMonitorSvc.h"
12926 #include "GaudiKernel/INTuple.h"
12927 #include "GaudiKernel/INTupleSvc.h"
12928 #include "GaudiKernel/INamedInterface.h"
12929 #include "GaudiKernel/IOpaqueAddress.h"
12930 #include "GaudiKernel/IPartPropSvc.h"
12931 #include "GaudiKernel/IParticlePropertySvc.h"
12932 #include "GaudiKernel/IPartitionControl.h"
12933 #include "GaudiKernel/IPersistencySvc.h"
12934 #include "GaudiKernel/IProperty.h"
12935 #include "GaudiKernel/IRegistry.h"
12936 #include "GaudiKernel/IRndmEngine.h"
12937 #include "GaudiKernel/IRndmGen.h"
12938 #include "GaudiKernel/IRndmGenSvc.h"
12939 #include "GaudiKernel/IRunable.h"
12940 #include "GaudiKernel/ISelectStatement.h"
12941 #include "GaudiKernel/ISerialize.h"
12942 #include "GaudiKernel/IService.h"
12943 #include "GaudiKernel/IStagerSvc.h"
12944 #include "GaudiKernel/IStatusCodeSvc.h"
12945 #include "GaudiKernel/ISvcLocator.h"
12946 #include "GaudiKernel/ISvcManager.h"
12947 #include "GaudiKernel/ITHistSvc.h"
12948 #include "GaudiKernel/IToolSvc.h"
12949 #include "GaudiKernel/IUpdateManagerSvc.h"
12950 #include "GaudiKernel/IUpdateable.h"
12951 #include "GaudiKernel/IValidity.h"
12952 #include "GaudiKernel/Incident.h"
12953 
12954 namespace GaudiKernelDict
12955 {
12956  struct __Instantiations : public KeyedObject<int>,
12957  public KeyedObject<unsigned int>,
12958  public KeyedObject<long>,
12959  public KeyedObject<unsigned long>,
12960  public SmartRef<DataObject>,
12961  public SmartRef<ContainedObject>,
12962  public SmartRef<ObjectContainerBase>,
12963  public SmartRef<KeyedObject<int>>,
12964  public SmartRef<KeyedObject<unsigned int>>,
12965  public SmartRef<KeyedObject<long>>,
12966  public SmartRef<KeyedObject<unsigned long>>,
12967  public SmartRefVector<DataObject>,
12968  public SmartRefVector<ContainedObject>,
12969  public SmartRefVector<ObjectContainerBase>,
12970  public SmartRefVector<KeyedObject<int>>,
12971  public SmartRefVector<KeyedObject<unsigned int>>,
12972  public SmartRefVector<KeyedObject<long>>,
12973  public SmartRefVector<KeyedObject<unsigned long>>,
12974  // public std::vector<SmartRef<ContainedObject> >,
12975  // public std::vector<SmartRef<DataObject> >,
12976  // public std::vector<SmartRef<ObjectContainerBase> >,
12977  public std::vector<LinkManager::Link*>,
12978  public std::vector<const ContainedObject*>,
12979  public std::vector<ContainedObject*> {
12980  NTuple::Item<bool> BoolItem;
12981  NTuple::Item<char> CharItem;
12982  NTuple::Item<unsigned char> UCharItem;
12983  NTuple::Item<short> ShortItem;
12984  NTuple::Item<unsigned short> UShortItem;
12985  NTuple::Item<long> LongItem;
12986  NTuple::Item<long long> LongLongItem;
12987  NTuple::Item<unsigned long> ULongItem;
12988  NTuple::Item<unsigned long long> ULongLongItem;
12989  NTuple::Item<int> IntItem;
12990  NTuple::Item<unsigned int> UIntItem;
12991  NTuple::Item<float> FloatItem;
12992  NTuple::Item<double> DoubleItem;
12993  NTuple::Array<bool> BoolArray;
12994  NTuple::Array<char> CharArray;
12995  NTuple::Array<unsigned char> UCharArray;
12996  NTuple::Array<short> ShortArray;
12997  NTuple::Array<unsigned short> UShortArray;
12998  NTuple::Array<long> LongArray;
12999  NTuple::Array<unsigned long> ULongArray;
13000  NTuple::Array<int> IntArray;
13001  NTuple::Array<unsigned int> UIntArray;
13002  NTuple::Array<float> FloatArray;
13003  NTuple::Array<double> DoubleArray;
13004  NTuple::Matrix<bool> BoolMatrix;
13005  NTuple::Matrix<char> CharMatrix;
13006  NTuple::Matrix<unsigned char> UCharMatrix;
13007  NTuple::Matrix<short> ShortMatrix;
13008  NTuple::Matrix<unsigned short> UShortMatrix;
13009  NTuple::Matrix<long> LongMatrix;
13010  NTuple::Matrix<unsigned long> ULongMatrix;
13011  NTuple::Matrix<int> IntMatrix;
13012  NTuple::Matrix<unsigned int> UIntMatrix;
13013  NTuple::Matrix<float> FloatMatrix;
13014  NTuple::Matrix<double> DoubleMatrix;
13015 
13016  SmartDataPtr<DataObject> p1;
13017  SmartDataPtr<ObjectContainerBase> p2;
13018  __Instantiations() : p1( 0, "" ), p2( 0, "" ) {}
13019  };
13020 }
13021 
13022 class IUpdateManagerSvc::PythonHelper
13023 {
13024 public:
13025  static StatusCode update( IUpdateManagerSvc* ums, void* obj ) { return ums->i_update( obj ); }
13026 
13027  static void invalidate( IUpdateManagerSvc* ums, void* obj ) { return ums->i_invalidate( obj ); }
13028 };
13029 
13030 #ifdef _WIN32
13031 // FIXME: (MCl) The generated dictionary produce a few warnings C4345, since I
13032 // cannot fix them, I just disable them.
13033 
13034 // Disable warning C4345: behavior change: an object of POD type constructed with an initializer of the
13035 // form () will be default-initialized
13036 #pragma warning( disable : 4345 )
13037 #endif
13038 
13039 #ifdef __ICC
13040 // disable icc warning #858: type qualifier on return type is meaningless
13041 // ... a lot of noise produced by the dictionary
13042 #pragma warning( disable : 858 )
13043 // disable icc remark #2259: non-pointer conversion from "int" to "const char &" may lose significant bits
13044 // Strange, things like NTuple::Item<char> produce this warning, as if the operation between chars are done
13045 // converting them to integers first.
13046 #pragma warning( disable : 2259 )
13047 // disable icc remark #177: variable "X" was declared but never referenced
13048 #pragma warning( disable : 177 )
13049 #endif
13050 
13051 #undef _BACKWARD_BACKWARD_WARNING_H
13052 )DICTPAYLOAD";
13053  static const char* classesHeaders[]={
13054 "", payloadCode, "@",
13055 "AlgTool", payloadCode, "@",
13056 "Algorithm", payloadCode, "@",
13057 "ContainedObject", payloadCode, "@",
13058 "Containers::KeyedObjectManager<Containers::array>", payloadCode, "@",
13059 "Containers::KeyedObjectManager<Containers::hashmap>", payloadCode, "@",
13060 "Containers::KeyedObjectManager<Containers::map>", payloadCode, "@",
13061 "Containers::KeyedObjectManager<Containers::vector>", payloadCode, "@",
13062 "DataObject", payloadCode, "@",
13063 "DataObjectHandleBase", payloadCode, "@",
13064 "DataObjectHandleProperty", payloadCode, "@",
13065 "Gaudi::CounterSummary::SaveType", payloadCode, "@",
13066 "Gaudi::Details::PropertyBase", payloadCode, "@",
13067 "Gaudi::Details::operator<<", payloadCode, "@",
13068 "Gaudi::Histos::book", payloadCode, "@",
13069 "Gaudi::Parsers::parse", payloadCode, "@",
13070 "Gaudi::PluginService::Debug", payloadCode, "@",
13071 "Gaudi::PluginService::Details::demangle", payloadCode, "@",
13072 "Gaudi::PluginService::Details::getDSONameFor", payloadCode, "@",
13073 "Gaudi::PluginService::Details::logger", payloadCode, "@",
13074 "Gaudi::PluginService::Details::reportBadAnyCast", payloadCode, "@",
13075 "Gaudi::PluginService::Details::setLogger", payloadCode, "@",
13076 "Gaudi::PluginService::SetDebug", payloadCode, "@",
13077 "Gaudi::StateMachine::ChangeState", payloadCode, "@",
13078 "Gaudi::StateMachine::State", payloadCode, "@",
13079 "Gaudi::StateMachine::Transition", payloadCode, "@",
13080 "Gaudi::StateMachine::operator<<", payloadCode, "@",
13081 "Gaudi::Time", payloadCode, "@",
13082 "Gaudi::Utils::getProperty", payloadCode, "@",
13083 "Gaudi::Utils::hasProperty", payloadCode, "@",
13084 "Gaudi::Utils::iequal", payloadCode, "@",
13085 "Gaudi::Utils::operator<<", payloadCode, "@",
13086 "Gaudi::Utils::setProperty", payloadCode, "@",
13087 "Gaudi::Utils::toStream", payloadCode, "@",
13088 "Gaudi::createApplicationMgr", payloadCode, "@",
13089 "Gaudi::createApplicationMgrEx", payloadCode, "@",
13090 "Gaudi::createInstance", payloadCode, "@",
13091 "Gaudi::details::rangeException", payloadCode, "@",
13092 "Gaudi::getCurrentDataObject", payloadCode, "@",
13093 "Gaudi::hash_value", payloadCode, "@",
13094 "Gaudi::operator!=", payloadCode, "@",
13095 "Gaudi::operator+", payloadCode, "@",
13096 "Gaudi::operator-", payloadCode, "@",
13097 "Gaudi::operator<", payloadCode, "@",
13098 "Gaudi::operator<<", payloadCode, "@",
13099 "Gaudi::operator<=", payloadCode, "@",
13100 "Gaudi::operator==", payloadCode, "@",
13101 "Gaudi::operator>", payloadCode, "@",
13102 "Gaudi::operator>=", payloadCode, "@",
13103 "Gaudi::popCurrentDataObject", payloadCode, "@",
13104 "Gaudi::pushCurrentDataObject", payloadCode, "@",
13105 "Gaudi::setInstance", payloadCode, "@",
13106 "Gaudi::svcLocator", payloadCode, "@",
13107 "Gaudi::tagged_bool_ns::operator!=", payloadCode, "@",
13108 "Gaudi::tagged_bool_ns::operator==", payloadCode, "@",
13109 "GaudiHandleArrayBase", payloadCode, "@",
13110 "GaudiHandleArrayProperty", payloadCode, "@",
13111 "GaudiHandleBase", payloadCode, "@",
13112 "GaudiHandleInfo", payloadCode, "@",
13113 "GaudiHandleProperty", payloadCode, "@",
13114 "GenericAddress", payloadCode, "@",
13115 "IAddressCreator", payloadCode, "@",
13116 "IAlgContextSvc", payloadCode, "@",
13117 "IAlgManager", payloadCode, "@",
13118 "IAlgTool", payloadCode, "@",
13119 "IAlgorithm", payloadCode, "@",
13120 "IAppMgrUI", payloadCode, "@",
13121 "IAuditor", payloadCode, "@",
13122 "IAuditorSvc", payloadCode, "@",
13123 "IChronoStatSvc", payloadCode, "@",
13124 "IChronoSvc", payloadCode, "@",
13125 "IClassInfo", payloadCode, "@",
13126 "IClassManager", payloadCode, "@",
13127 "IConversionSvc", payloadCode, "@",
13128 "IConverter", payloadCode, "@",
13129 "ICounterSummarySvc", payloadCode, "@",
13130 "IDataManagerSvc", payloadCode, "@",
13131 "IDataProviderSvc", payloadCode, "@",
13132 "IDataSelector", payloadCode, "@",
13133 "IDataSourceMgr", payloadCode, "@",
13134 "IDataStoreAgent", payloadCode, "@",
13135 "IDataStoreLeaves", payloadCode, "@",
13136 "IDataStreamTool", payloadCode, "@",
13137 "IDetDataSvc", payloadCode, "@",
13138 "IEventProcessor", payloadCode, "@",
13139 "IEventTimeDecoder", payloadCode, "@",
13140 "IEvtSelector", payloadCode, "@",
13141 "IExceptionSvc", payloadCode, "@",
13142 "IHistogramSvc", payloadCode, "@",
13143 "IHistorySvc", payloadCode, "@",
13144 "IIncidentListener", payloadCode, "@",
13145 "IIncidentSvc", payloadCode, "@",
13146 "IInspectable", payloadCode, "@",
13147 "IInspector", payloadCode, "@",
13148 "IInterface", payloadCode, "@",
13149 "IJobOptionsSvc", payloadCode, "@",
13150 "IMagneticFieldSvc", payloadCode, "@",
13151 "IMessageSvc", payloadCode, "@",
13152 "IMonitorSvc", payloadCode, "@",
13153 "INTuple", payloadCode, "@",
13154 "INTupleSvc", payloadCode, "@",
13155 "INamedInterface", payloadCode, "@",
13156 "IOpaqueAddress", payloadCode, "@",
13157 "IPartPropSvc", payloadCode, "@",
13158 "IParticlePropertySvc", payloadCode, "@",
13159 "IPartitionControl", payloadCode, "@",
13160 "IPersistencySvc", payloadCode, "@",
13161 "IProperty", payloadCode, "@",
13162 "IRegistry", payloadCode, "@",
13163 "IRndmEngine", payloadCode, "@",
13164 "IRndmGen", payloadCode, "@",
13165 "IRndmGen::Param", payloadCode, "@",
13166 "IRndmGenSvc", payloadCode, "@",
13167 "IRunable", payloadCode, "@",
13168 "ISelectStatement", payloadCode, "@",
13169 "ISerialize", payloadCode, "@",
13170 "IService", payloadCode, "@",
13171 "IStagerSvc", payloadCode, "@",
13172 "IStatSvc", payloadCode, "@",
13173 "IStateful", payloadCode, "@",
13174 "IStatusCodeSvc", payloadCode, "@",
13175 "ISvcLocator", payloadCode, "@",
13176 "ISvcManager", payloadCode, "@",
13177 "ITHistSvc", payloadCode, "@",
13178 "IToolSvc", payloadCode, "@",
13179 "IUpdateManagerSvc", payloadCode, "@",
13180 "IUpdateManagerSvc::PythonHelper", payloadCode, "@",
13181 "IUpdateable", payloadCode, "@",
13182 "IValidity", payloadCode, "@",
13183 "Incident", payloadCode, "@",
13184 "InterfaceID", payloadCode, "@",
13185 "KeyedObject<int>", payloadCode, "@",
13186 "KeyedObject<long>", payloadCode, "@",
13187 "KeyedObject<unsigned int>", payloadCode, "@",
13188 "KeyedObject<unsigned long>", payloadCode, "@",
13189 "LinkManager", payloadCode, "@",
13190 "LinkManager::Link", payloadCode, "@",
13191 "MSG::Color", payloadCode, "@",
13192 "MSG::Level", payloadCode, "@",
13193 "NTuple::Array<IOpaqueAddress*>", payloadCode, "@",
13194 "NTuple::Array<bool>", payloadCode, "@",
13195 "NTuple::Array<char>", payloadCode, "@",
13196 "NTuple::Array<double>", payloadCode, "@",
13197 "NTuple::Array<float>", payloadCode, "@",
13198 "NTuple::Array<int>", payloadCode, "@",
13199 "NTuple::Array<long>", payloadCode, "@",
13200 "NTuple::Array<short>", payloadCode, "@",
13201 "NTuple::Array<unsigned char>", payloadCode, "@",
13202 "NTuple::Array<unsigned int>", payloadCode, "@",
13203 "NTuple::Array<unsigned long>", payloadCode, "@",
13204 "NTuple::Array<unsigned short>", payloadCode, "@",
13205 "NTuple::ColumnWiseTuple", payloadCode, "@",
13206 "NTuple::Directory", payloadCode, "@",
13207 "NTuple::File", payloadCode, "@",
13208 "NTuple::Item<Long64_t>", payloadCode, "@",
13209 "NTuple::Item<ULong64_t>", payloadCode, "@",
13210 "NTuple::Item<bool>", payloadCode, "@",
13211 "NTuple::Item<char>", payloadCode, "@",
13212 "NTuple::Item<double>", payloadCode, "@",
13213 "NTuple::Item<float>", payloadCode, "@",
13214 "NTuple::Item<int>", payloadCode, "@",
13215 "NTuple::Item<long>", payloadCode, "@",
13216 "NTuple::Item<short>", payloadCode, "@",
13217 "NTuple::Item<unsigned char>", payloadCode, "@",
13218 "NTuple::Item<unsigned int>", payloadCode, "@",
13219 "NTuple::Item<unsigned long>", payloadCode, "@",
13220 "NTuple::Item<unsigned short>", payloadCode, "@",
13221 "NTuple::Matrix<IOpaqueAddress*>", payloadCode, "@",
13222 "NTuple::Matrix<bool>", payloadCode, "@",
13223 "NTuple::Matrix<char>", payloadCode, "@",
13224 "NTuple::Matrix<double>", payloadCode, "@",
13225 "NTuple::Matrix<float>", payloadCode, "@",
13226 "NTuple::Matrix<int>", payloadCode, "@",
13227 "NTuple::Matrix<long>", payloadCode, "@",
13228 "NTuple::Matrix<short>", payloadCode, "@",
13229 "NTuple::Matrix<unsigned char>", payloadCode, "@",
13230 "NTuple::Matrix<unsigned int>", payloadCode, "@",
13231 "NTuple::Matrix<unsigned long>", payloadCode, "@",
13232 "NTuple::Matrix<unsigned short>", payloadCode, "@",
13233 "NTuple::RowWiseTuple", payloadCode, "@",
13234 "ObjectContainerBase", payloadCode, "@",
13235 "Rndm::Binomial", payloadCode, "@",
13236 "Rndm::Bit", payloadCode, "@",
13237 "Rndm::BreitWigner", payloadCode, "@",
13238 "Rndm::BreitWignerCutOff", payloadCode, "@",
13239 "Rndm::Chi2", payloadCode, "@",
13240 "Rndm::DefinedPdf", payloadCode, "@",
13241 "Rndm::Exponential", payloadCode, "@",
13242 "Rndm::Flat", payloadCode, "@",
13243 "Rndm::Gamma", payloadCode, "@",
13244 "Rndm::Gauss", payloadCode, "@",
13245 "Rndm::GaussianTail", payloadCode, "@",
13246 "Rndm::Landau", payloadCode, "@",
13247 "Rndm::Numbers", payloadCode, "@",
13248 "Rndm::Poisson", payloadCode, "@",
13249 "Rndm::StudentT", payloadCode, "@",
13250 "Service", payloadCode, "@",
13251 "SmartDataObjectPtr", payloadCode, "@",
13252 "SmartDataPtr<DataObject>", payloadCode, "@",
13253 "SmartDataPtr<ObjectContainerBase>", payloadCode, "@",
13254 "SmartDataStorePtr<DataObject,SmartDataObjectPtr::ObjectLoader>", payloadCode, "@",
13255 "SmartDataStorePtr<ObjectContainerBase,SmartDataObjectPtr::ObjectLoader>", payloadCode, "@",
13256 "SmartIF<IAlgContextSvc>", payloadCode, "@",
13257 "SmartIF<IAlgExecStateSvc>", payloadCode, "@",
13258 "SmartIF<IAlgorithm>", payloadCode, "@",
13259 "SmartIF<IAuditorSvc>", payloadCode, "@",
13260 "SmartIF<IChronoStatSvc>", payloadCode, "@",
13261 "SmartIF<IConversionSvc>", payloadCode, "@",
13262 "SmartIF<IDataProviderSvc>", payloadCode, "@",
13263 "SmartIF<IEvtSelector>", payloadCode, "@",
13264 "SmartIF<IExceptionSvc>", payloadCode, "@",
13265 "SmartIF<IHistogramSvc>", payloadCode, "@",
13266 "SmartIF<IHiveWhiteBoard>", payloadCode, "@",
13267 "SmartIF<IIncidentSvc>", payloadCode, "@",
13268 "SmartIF<IMessageSvc>", payloadCode, "@",
13269 "SmartIF<IMonitorSvc>", payloadCode, "@",
13270 "SmartIF<INTupleSvc>", payloadCode, "@",
13271 "SmartIF<IProperty>", payloadCode, "@",
13272 "SmartIF<IRndmGen>", payloadCode, "@",
13273 "SmartIF<IRndmGenSvc>", payloadCode, "@",
13274 "SmartIF<ISelectStatement>", payloadCode, "@",
13275 "SmartIF<IService>", payloadCode, "@",
13276 "SmartIF<ISvcLocator>", payloadCode, "@",
13277 "SmartIF<ISvcManager>", payloadCode, "@",
13278 "SmartIF<ITimelineSvc>", payloadCode, "@",
13279 "SmartIF<IToolSvc>", payloadCode, "@",
13280 "SmartRef<ContainedObject>", payloadCode, "@",
13281 "SmartRef<DataObject>", payloadCode, "@",
13282 "SmartRef<KeyedObject<int> >", payloadCode, "@",
13283 "SmartRef<KeyedObject<long> >", payloadCode, "@",
13284 "SmartRef<KeyedObject<unsigned int> >", payloadCode, "@",
13285 "SmartRef<KeyedObject<unsigned long> >", payloadCode, "@",
13286 "SmartRef<ObjectContainerBase>", payloadCode, "@",
13287 "SmartRefBase", payloadCode, "@",
13288 "SmartRefVector<ContainedObject>", payloadCode, "@",
13289 "SmartRefVector<DataObject>", payloadCode, "@",
13290 "SmartRefVector<KeyedObject<int> >", payloadCode, "@",
13291 "SmartRefVector<KeyedObject<long> >", payloadCode, "@",
13292 "SmartRefVector<KeyedObject<unsigned int> >", payloadCode, "@",
13293 "SmartRefVector<KeyedObject<unsigned long> >", payloadCode, "@",
13294 "SmartRefVector<ObjectContainerBase>", payloadCode, "@",
13295 "StatusCode", payloadCode, "@",
13296 "System::accountName", payloadCode, "@",
13297 "System::adjustMemory", payloadCode, "@",
13298 "System::adjustTime", payloadCode, "@",
13299 "System::affinityMask", payloadCode, "@",
13300 "System::argc", payloadCode, "@",
13301 "System::argv", payloadCode, "@",
13302 "System::backTrace", payloadCode, "@",
13303 "System::basePriority", payloadCode, "@",
13304 "System::breakExecution", payloadCode, "@",
13305 "System::cmdLineArgs", payloadCode, "@",
13306 "System::cpuTime", payloadCode, "@",
13307 "System::creationTime", payloadCode, "@",
13308 "System::currentTime", payloadCode, "@",
13309 "System::ellapsedTime", payloadCode, "@",
13310 "System::exeHandle", payloadCode, "@",
13311 "System::exeName", payloadCode, "@",
13312 "System::exitStatus", payloadCode, "@",
13313 "System::getEnv", payloadCode, "@",
13314 "System::getErrorString", payloadCode, "@",
13315 "System::getLastError", payloadCode, "@",
13316 "System::getLastErrorString", payloadCode, "@",
13317 "System::getProcedureByName", payloadCode, "@",
13318 "System::getProcessTime", payloadCode, "@",
13319 "System::getStackLevel", payloadCode, "@",
13320 "System::homeDirectory", payloadCode, "@",
13321 "System::hostName", payloadCode, "@",
13322 "System::instructionsetLevel", payloadCode, "@",
13323 "System::isEnvSet", payloadCode, "@",
13324 "System::kernelTime", payloadCode, "@",
13325 "System::linkedModules", payloadCode, "@",
13326 "System::loadDynamicLib", payloadCode, "@",
13327 "System::machineType", payloadCode, "@",
13328 "System::mappedMemory", payloadCode, "@",
13329 "System::mappedMemoryPeak", payloadCode, "@",
13330 "System::maxMemoryLimit", payloadCode, "@",
13331 "System::minMemoryLimit", payloadCode, "@",
13332 "System::moduleHandle", payloadCode, "@",
13333 "System::moduleName", payloadCode, "@",
13334 "System::moduleNameFull", payloadCode, "@",
13335 "System::moduleType", payloadCode, "@",
13336 "System::nonPagedMemory", payloadCode, "@",
13337 "System::nonPagedMemoryLimit", payloadCode, "@",
13338 "System::nonPagedMemoryPeak", payloadCode, "@",
13339 "System::numCmdLineArgs", payloadCode, "@",
13340 "System::numPageFault", payloadCode, "@",
13341 "System::osName", payloadCode, "@",
13342 "System::osVersion", payloadCode, "@",
13343 "System::pagedMemory", payloadCode, "@",
13344 "System::pagedMemoryLimit", payloadCode, "@",
13345 "System::pagedMemoryPeak", payloadCode, "@",
13346 "System::pagefileUsage", payloadCode, "@",
13347 "System::pagefileUsageLimit", payloadCode, "@",
13348 "System::pagefileUsagePeak", payloadCode, "@",
13349 "System::parentID", payloadCode, "@",
13350 "System::priorityBoost", payloadCode, "@",
13351 "System::procID", payloadCode, "@",
13352 "System::processHandle", payloadCode, "@",
13353 "System::remainingTime", payloadCode, "@",
13354 "System::resolveEnv", payloadCode, "@",
13355 "System::setEnv", payloadCode, "@",
13356 "System::setModuleHandle", payloadCode, "@",
13357 "System::systemStart", payloadCode, "@",
13358 "System::tempDirectory", payloadCode, "@",
13359 "System::threadSelf", payloadCode, "@",
13360 "System::tickCount", payloadCode, "@",
13361 "System::typeinfoName", payloadCode, "@",
13362 "System::unloadDynamicLib", payloadCode, "@",
13363 "System::upTime", payloadCode, "@",
13364 "System::userTime", payloadCode, "@",
13365 "System::virtualMemory", payloadCode, "@",
13366 "System::virtualMemoryLimit", payloadCode, "@",
13367 "System::virtualMemoryPeak", payloadCode, "@",
13368 nullptr};
13369 
13370  static bool isInitialized = false;
13371  if (!isInitialized) {
13372  TROOT::RegisterModule("GaudiKernelDict",
13373  headers, includePaths, payloadCode, fwdDeclCode,
13374  TriggerDictionaryInitialization_GaudiKernelDict_Impl, {}, classesHeaders);
13375  isInitialized = true;
13376  }
13377  }
13378  static struct DictInit {
13379  DictInit() {
13380  TriggerDictionaryInitialization_GaudiKernelDict_Impl();
13381  }
13382  } __TheDictionaryInitializer;
13383 }
13384 void TriggerDictionaryInitialization_GaudiKernelDict() {
13385  TriggerDictionaryInitialization_GaudiKernelDict_Impl();
13386 }
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:279
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:210
IClassInfo
Data base class allowing to store persistent type information.
Definition: IClassInfo.h:12
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:46
details::size
constexpr auto size(const C &c) noexcept(noexcept(c.size())) -> decltype(c.size())
Definition: AnyDataWrapper.h:14
DataObjectHandleProperty
DataObjectHandleProperty.h GaudiKernel/DataObjectHandleProperty.h.
Definition: DataObjectHandleProperty.h:23
ROOT::GenerateInitInstance
TGenericClassInfo * GenerateInitInstance(const ::IUpdateManagerSvc::PythonHelper *)
Definition: GaudiKernelDict.cpp:8529
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:368
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:51
Rndm::Flat
Parameters for the flat random number generation within boundaries [minimum, maximum].
Definition: RndmGenerators.h:256
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:141
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:316
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:163
Rndm::Binomial
Parameters for the Binomial distributed random number generation.
Definition: RndmGenerators.h:232
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:78
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:354
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:111
Rndm::Chi2
Parameters for the Chi2 distributed random number generation.
Definition: RndmGenerators.h:67
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:135
DataObjectHandleBase
DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h.
Definition: DataObjectHandleBase.h:26
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:184
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:47
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
NTuple::Directory
Small class representing an N tuple directory in the transient store.
Definition: NTuple.h:978
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:13384
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:94
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:332
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:306
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:48
DataObject
A DataObject is the base class of any identifiable object on any data store.
Definition: DataObject.h:30
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:88
NTuple::File
Small class representing an N tuple file in the transient store.
Definition: NTuple.h:987
IHistorySvc
Definition of the IHistorySvc interface class.
Definition: IHistorySvc.h:31