The Gaudi Framework  v29r5 (37229091)
GaudiPythonDict.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 GaudiPythonDict
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/GaudiPython/dict/kernel.h"
41 
42 // Header files passed via #pragma extra_include
43 
44 namespace ROOT {
45  static TClass *allocatorlEIServicemUgR_Dictionary();
46  static void allocatorlEIServicemUgR_TClassManip(TClass*);
47  static void *new_allocatorlEIServicemUgR(void *p = 0);
48  static void *newArray_allocatorlEIServicemUgR(Long_t size, void *p);
49  static void delete_allocatorlEIServicemUgR(void *p);
50  static void deleteArray_allocatorlEIServicemUgR(void *p);
51  static void destruct_allocatorlEIServicemUgR(void *p);
52 
53  // Function generating the singleton type initializer
54  static TGenericClassInfo *GenerateInitInstanceLocal(const allocator<IService*>*)
55  {
56  allocator<IService*> *ptr = 0;
57  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(allocator<IService*>));
58  static ::ROOT::TGenericClassInfo
59  instance("allocator<IService*>", "string", 97,
60  typeid(allocator<IService*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
61  &allocatorlEIServicemUgR_Dictionary, isa_proxy, 4,
62  sizeof(allocator<IService*>) );
63  instance.SetNew(&new_allocatorlEIServicemUgR);
64  instance.SetNewArray(&newArray_allocatorlEIServicemUgR);
65  instance.SetDelete(&delete_allocatorlEIServicemUgR);
66  instance.SetDeleteArray(&deleteArray_allocatorlEIServicemUgR);
67  instance.SetDestructor(&destruct_allocatorlEIServicemUgR);
68  return &instance;
69  }
70  // Static variable to force the class initialization
71  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const allocator<IService*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
72 
73  // Dictionary for non-ClassDef classes
74  static TClass *allocatorlEIServicemUgR_Dictionary() {
75  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const allocator<IService*>*)0x0)->GetClass();
76  allocatorlEIServicemUgR_TClassManip(theClass);
77  return theClass;
78  }
79 
80  static void allocatorlEIServicemUgR_TClassManip(TClass* ){
81  }
82 
83 } // end of namespace ROOT
84 
85 namespace ROOT {
86  static TClass *allocatorlEIAlgorithmmUgR_Dictionary();
87  static void allocatorlEIAlgorithmmUgR_TClassManip(TClass*);
88  static void *new_allocatorlEIAlgorithmmUgR(void *p = 0);
89  static void *newArray_allocatorlEIAlgorithmmUgR(Long_t size, void *p);
90  static void delete_allocatorlEIAlgorithmmUgR(void *p);
91  static void deleteArray_allocatorlEIAlgorithmmUgR(void *p);
92  static void destruct_allocatorlEIAlgorithmmUgR(void *p);
93 
94  // Function generating the singleton type initializer
95  static TGenericClassInfo *GenerateInitInstanceLocal(const allocator<IAlgorithm*>*)
96  {
97  allocator<IAlgorithm*> *ptr = 0;
98  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(allocator<IAlgorithm*>));
99  static ::ROOT::TGenericClassInfo
100  instance("allocator<IAlgorithm*>", "string", 97,
101  typeid(allocator<IAlgorithm*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
102  &allocatorlEIAlgorithmmUgR_Dictionary, isa_proxy, 4,
103  sizeof(allocator<IAlgorithm*>) );
104  instance.SetNew(&new_allocatorlEIAlgorithmmUgR);
105  instance.SetNewArray(&newArray_allocatorlEIAlgorithmmUgR);
106  instance.SetDelete(&delete_allocatorlEIAlgorithmmUgR);
107  instance.SetDeleteArray(&deleteArray_allocatorlEIAlgorithmmUgR);
108  instance.SetDestructor(&destruct_allocatorlEIAlgorithmmUgR);
109  return &instance;
110  }
111  // Static variable to force the class initialization
112  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const allocator<IAlgorithm*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
113 
114  // Dictionary for non-ClassDef classes
115  static TClass *allocatorlEIAlgorithmmUgR_Dictionary() {
116  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const allocator<IAlgorithm*>*)0x0)->GetClass();
117  allocatorlEIAlgorithmmUgR_TClassManip(theClass);
118  return theClass;
119  }
120 
121  static void allocatorlEIAlgorithmmUgR_TClassManip(TClass* ){
122  }
123 
124 } // end of namespace ROOT
125 
126 namespace ROOT {
127  static TClass *allocatorlEIRegistrymUgR_Dictionary();
128  static void allocatorlEIRegistrymUgR_TClassManip(TClass*);
129  static void *new_allocatorlEIRegistrymUgR(void *p = 0);
130  static void *newArray_allocatorlEIRegistrymUgR(Long_t size, void *p);
131  static void delete_allocatorlEIRegistrymUgR(void *p);
132  static void deleteArray_allocatorlEIRegistrymUgR(void *p);
133  static void destruct_allocatorlEIRegistrymUgR(void *p);
134 
135  // Function generating the singleton type initializer
136  static TGenericClassInfo *GenerateInitInstanceLocal(const allocator<IRegistry*>*)
137  {
138  allocator<IRegistry*> *ptr = 0;
139  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(allocator<IRegistry*>));
140  static ::ROOT::TGenericClassInfo
141  instance("allocator<IRegistry*>", "string", 97,
142  typeid(allocator<IRegistry*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
143  &allocatorlEIRegistrymUgR_Dictionary, isa_proxy, 4,
144  sizeof(allocator<IRegistry*>) );
145  instance.SetNew(&new_allocatorlEIRegistrymUgR);
146  instance.SetNewArray(&newArray_allocatorlEIRegistrymUgR);
147  instance.SetDelete(&delete_allocatorlEIRegistrymUgR);
148  instance.SetDeleteArray(&deleteArray_allocatorlEIRegistrymUgR);
149  instance.SetDestructor(&destruct_allocatorlEIRegistrymUgR);
150  return &instance;
151  }
152  // Static variable to force the class initialization
153  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const allocator<IRegistry*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
154 
155  // Dictionary for non-ClassDef classes
156  static TClass *allocatorlEIRegistrymUgR_Dictionary() {
157  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const allocator<IRegistry*>*)0x0)->GetClass();
158  allocatorlEIRegistrymUgR_TClassManip(theClass);
159  return theClass;
160  }
161 
162  static void allocatorlEIRegistrymUgR_TClassManip(TClass* ){
163  }
164 
165 } // end of namespace ROOT
166 
167 namespace ROOT {
168  static TClass *basic_ostreamlEcharcOchar_traitslEchargRsPgR_Dictionary();
169  static void basic_ostreamlEcharcOchar_traitslEchargRsPgR_TClassManip(TClass*);
170  static void delete_basic_ostreamlEcharcOchar_traitslEchargRsPgR(void *p);
171  static void deleteArray_basic_ostreamlEcharcOchar_traitslEchargRsPgR(void *p);
172  static void destruct_basic_ostreamlEcharcOchar_traitslEchargRsPgR(void *p);
173 
174  // Function generating the singleton type initializer
175  static TGenericClassInfo *GenerateInitInstanceLocal(const ::basic_ostream<char,char_traits<char> >*)
176  {
177  ::basic_ostream<char,char_traits<char> > *ptr = 0;
178  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::basic_ostream<char,char_traits<char> >));
179  static ::ROOT::TGenericClassInfo
180  instance("basic_ostream<char,char_traits<char> >", "ostream", 359,
181  typeid(::basic_ostream<char,char_traits<char> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
182  &basic_ostreamlEcharcOchar_traitslEchargRsPgR_Dictionary, isa_proxy, 4,
183  sizeof(::basic_ostream<char,char_traits<char> >) );
184  instance.SetDelete(&delete_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
185  instance.SetDeleteArray(&deleteArray_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
186  instance.SetDestructor(&destruct_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
187 
188  ::ROOT::AddClassAlternate("basic_ostream<char,char_traits<char> >","ostream");
189  return &instance;
190  }
191  // Static variable to force the class initialization
192  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::basic_ostream<char,char_traits<char> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
193 
194  // Dictionary for non-ClassDef classes
195  static TClass *basic_ostreamlEcharcOchar_traitslEchargRsPgR_Dictionary() {
196  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::basic_ostream<char,char_traits<char> >*)0x0)->GetClass();
197  basic_ostreamlEcharcOchar_traitslEchargRsPgR_TClassManip(theClass);
198  return theClass;
199  }
200 
201  static void basic_ostreamlEcharcOchar_traitslEchargRsPgR_TClassManip(TClass* ){
202  }
203 
204 } // end of namespace ROOT
205 
206 namespace ROOT {
207  static TClass *unary_functionlEboolcOunsignedsPlonggR_Dictionary();
208  static void unary_functionlEboolcOunsignedsPlonggR_TClassManip(TClass*);
209  static void *new_unary_functionlEboolcOunsignedsPlonggR(void *p = 0);
210  static void *newArray_unary_functionlEboolcOunsignedsPlonggR(Long_t size, void *p);
211  static void delete_unary_functionlEboolcOunsignedsPlonggR(void *p);
212  static void deleteArray_unary_functionlEboolcOunsignedsPlonggR(void *p);
213  static void destruct_unary_functionlEboolcOunsignedsPlonggR(void *p);
214 
215  // Function generating the singleton type initializer
216  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<bool,unsigned long>*)
217  {
218  ::unary_function<bool,unsigned long> *ptr = 0;
219  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<bool,unsigned long>));
220  static ::ROOT::TGenericClassInfo
221  instance("unary_function<bool,unsigned long>", "string", 105,
222  typeid(::unary_function<bool,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
223  &unary_functionlEboolcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
224  sizeof(::unary_function<bool,unsigned long>) );
225  instance.SetNew(&new_unary_functionlEboolcOunsignedsPlonggR);
226  instance.SetNewArray(&newArray_unary_functionlEboolcOunsignedsPlonggR);
227  instance.SetDelete(&delete_unary_functionlEboolcOunsignedsPlonggR);
228  instance.SetDeleteArray(&deleteArray_unary_functionlEboolcOunsignedsPlonggR);
229  instance.SetDestructor(&destruct_unary_functionlEboolcOunsignedsPlonggR);
230  return &instance;
231  }
232  // Static variable to force the class initialization
233  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<bool,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
234 
235  // Dictionary for non-ClassDef classes
236  static TClass *unary_functionlEboolcOunsignedsPlonggR_Dictionary() {
237  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<bool,unsigned long>*)0x0)->GetClass();
238  unary_functionlEboolcOunsignedsPlonggR_TClassManip(theClass);
239  return theClass;
240  }
241 
242  static void unary_functionlEboolcOunsignedsPlonggR_TClassManip(TClass* ){
243  }
244 
245 } // end of namespace ROOT
246 
247 namespace ROOT {
248  static TClass *unary_functionlEcharcOunsignedsPlonggR_Dictionary();
249  static void unary_functionlEcharcOunsignedsPlonggR_TClassManip(TClass*);
250  static void *new_unary_functionlEcharcOunsignedsPlonggR(void *p = 0);
251  static void *newArray_unary_functionlEcharcOunsignedsPlonggR(Long_t size, void *p);
252  static void delete_unary_functionlEcharcOunsignedsPlonggR(void *p);
253  static void deleteArray_unary_functionlEcharcOunsignedsPlonggR(void *p);
254  static void destruct_unary_functionlEcharcOunsignedsPlonggR(void *p);
255 
256  // Function generating the singleton type initializer
257  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<char,unsigned long>*)
258  {
259  ::unary_function<char,unsigned long> *ptr = 0;
260  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<char,unsigned long>));
261  static ::ROOT::TGenericClassInfo
262  instance("unary_function<char,unsigned long>", "string", 105,
263  typeid(::unary_function<char,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
264  &unary_functionlEcharcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
265  sizeof(::unary_function<char,unsigned long>) );
266  instance.SetNew(&new_unary_functionlEcharcOunsignedsPlonggR);
267  instance.SetNewArray(&newArray_unary_functionlEcharcOunsignedsPlonggR);
268  instance.SetDelete(&delete_unary_functionlEcharcOunsignedsPlonggR);
269  instance.SetDeleteArray(&deleteArray_unary_functionlEcharcOunsignedsPlonggR);
270  instance.SetDestructor(&destruct_unary_functionlEcharcOunsignedsPlonggR);
271  return &instance;
272  }
273  // Static variable to force the class initialization
274  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<char,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
275 
276  // Dictionary for non-ClassDef classes
277  static TClass *unary_functionlEcharcOunsignedsPlonggR_Dictionary() {
278  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<char,unsigned long>*)0x0)->GetClass();
279  unary_functionlEcharcOunsignedsPlonggR_TClassManip(theClass);
280  return theClass;
281  }
282 
283  static void unary_functionlEcharcOunsignedsPlonggR_TClassManip(TClass* ){
284  }
285 
286 } // end of namespace ROOT
287 
288 namespace ROOT {
289  static TClass *unary_functionlEsignedsPcharcOunsignedsPlonggR_Dictionary();
290  static void unary_functionlEsignedsPcharcOunsignedsPlonggR_TClassManip(TClass*);
291  static void *new_unary_functionlEsignedsPcharcOunsignedsPlonggR(void *p = 0);
292  static void *newArray_unary_functionlEsignedsPcharcOunsignedsPlonggR(Long_t size, void *p);
293  static void delete_unary_functionlEsignedsPcharcOunsignedsPlonggR(void *p);
294  static void deleteArray_unary_functionlEsignedsPcharcOunsignedsPlonggR(void *p);
295  static void destruct_unary_functionlEsignedsPcharcOunsignedsPlonggR(void *p);
296 
297  // Function generating the singleton type initializer
298  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<signed char,unsigned long>*)
299  {
300  ::unary_function<signed char,unsigned long> *ptr = 0;
301  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<signed char,unsigned long>));
302  static ::ROOT::TGenericClassInfo
303  instance("unary_function<signed char,unsigned long>", "string", 105,
304  typeid(::unary_function<signed char,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
305  &unary_functionlEsignedsPcharcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
306  sizeof(::unary_function<signed char,unsigned long>) );
307  instance.SetNew(&new_unary_functionlEsignedsPcharcOunsignedsPlonggR);
308  instance.SetNewArray(&newArray_unary_functionlEsignedsPcharcOunsignedsPlonggR);
309  instance.SetDelete(&delete_unary_functionlEsignedsPcharcOunsignedsPlonggR);
310  instance.SetDeleteArray(&deleteArray_unary_functionlEsignedsPcharcOunsignedsPlonggR);
311  instance.SetDestructor(&destruct_unary_functionlEsignedsPcharcOunsignedsPlonggR);
312  return &instance;
313  }
314  // Static variable to force the class initialization
315  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<signed char,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
316 
317  // Dictionary for non-ClassDef classes
318  static TClass *unary_functionlEsignedsPcharcOunsignedsPlonggR_Dictionary() {
319  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<signed char,unsigned long>*)0x0)->GetClass();
320  unary_functionlEsignedsPcharcOunsignedsPlonggR_TClassManip(theClass);
321  return theClass;
322  }
323 
324  static void unary_functionlEsignedsPcharcOunsignedsPlonggR_TClassManip(TClass* ){
325  }
326 
327 } // end of namespace ROOT
328 
329 namespace ROOT {
330  static TClass *unary_functionlEunsignedsPcharcOunsignedsPlonggR_Dictionary();
331  static void unary_functionlEunsignedsPcharcOunsignedsPlonggR_TClassManip(TClass*);
332  static void *new_unary_functionlEunsignedsPcharcOunsignedsPlonggR(void *p = 0);
333  static void *newArray_unary_functionlEunsignedsPcharcOunsignedsPlonggR(Long_t size, void *p);
334  static void delete_unary_functionlEunsignedsPcharcOunsignedsPlonggR(void *p);
335  static void deleteArray_unary_functionlEunsignedsPcharcOunsignedsPlonggR(void *p);
336  static void destruct_unary_functionlEunsignedsPcharcOunsignedsPlonggR(void *p);
337 
338  // Function generating the singleton type initializer
339  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<unsigned char,unsigned long>*)
340  {
341  ::unary_function<unsigned char,unsigned long> *ptr = 0;
342  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<unsigned char,unsigned long>));
343  static ::ROOT::TGenericClassInfo
344  instance("unary_function<unsigned char,unsigned long>", "string", 105,
345  typeid(::unary_function<unsigned char,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
346  &unary_functionlEunsignedsPcharcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
347  sizeof(::unary_function<unsigned char,unsigned long>) );
348  instance.SetNew(&new_unary_functionlEunsignedsPcharcOunsignedsPlonggR);
349  instance.SetNewArray(&newArray_unary_functionlEunsignedsPcharcOunsignedsPlonggR);
350  instance.SetDelete(&delete_unary_functionlEunsignedsPcharcOunsignedsPlonggR);
351  instance.SetDeleteArray(&deleteArray_unary_functionlEunsignedsPcharcOunsignedsPlonggR);
352  instance.SetDestructor(&destruct_unary_functionlEunsignedsPcharcOunsignedsPlonggR);
353  return &instance;
354  }
355  // Static variable to force the class initialization
356  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<unsigned char,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
357 
358  // Dictionary for non-ClassDef classes
359  static TClass *unary_functionlEunsignedsPcharcOunsignedsPlonggR_Dictionary() {
360  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<unsigned char,unsigned long>*)0x0)->GetClass();
361  unary_functionlEunsignedsPcharcOunsignedsPlonggR_TClassManip(theClass);
362  return theClass;
363  }
364 
365  static void unary_functionlEunsignedsPcharcOunsignedsPlonggR_TClassManip(TClass* ){
366  }
367 
368 } // end of namespace ROOT
369 
370 namespace ROOT {
371  static TClass *unary_functionlEwchar_tcOunsignedsPlonggR_Dictionary();
372  static void unary_functionlEwchar_tcOunsignedsPlonggR_TClassManip(TClass*);
373  static void *new_unary_functionlEwchar_tcOunsignedsPlonggR(void *p = 0);
374  static void *newArray_unary_functionlEwchar_tcOunsignedsPlonggR(Long_t size, void *p);
375  static void delete_unary_functionlEwchar_tcOunsignedsPlonggR(void *p);
376  static void deleteArray_unary_functionlEwchar_tcOunsignedsPlonggR(void *p);
377  static void destruct_unary_functionlEwchar_tcOunsignedsPlonggR(void *p);
378 
379  // Function generating the singleton type initializer
380  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<wchar_t,unsigned long>*)
381  {
382  ::unary_function<wchar_t,unsigned long> *ptr = 0;
383  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<wchar_t,unsigned long>));
384  static ::ROOT::TGenericClassInfo
385  instance("unary_function<wchar_t,unsigned long>", "string", 105,
386  typeid(::unary_function<wchar_t,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
387  &unary_functionlEwchar_tcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
388  sizeof(::unary_function<wchar_t,unsigned long>) );
389  instance.SetNew(&new_unary_functionlEwchar_tcOunsignedsPlonggR);
390  instance.SetNewArray(&newArray_unary_functionlEwchar_tcOunsignedsPlonggR);
391  instance.SetDelete(&delete_unary_functionlEwchar_tcOunsignedsPlonggR);
392  instance.SetDeleteArray(&deleteArray_unary_functionlEwchar_tcOunsignedsPlonggR);
393  instance.SetDestructor(&destruct_unary_functionlEwchar_tcOunsignedsPlonggR);
394  return &instance;
395  }
396  // Static variable to force the class initialization
397  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<wchar_t,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
398 
399  // Dictionary for non-ClassDef classes
400  static TClass *unary_functionlEwchar_tcOunsignedsPlonggR_Dictionary() {
401  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<wchar_t,unsigned long>*)0x0)->GetClass();
402  unary_functionlEwchar_tcOunsignedsPlonggR_TClassManip(theClass);
403  return theClass;
404  }
405 
406  static void unary_functionlEwchar_tcOunsignedsPlonggR_TClassManip(TClass* ){
407  }
408 
409 } // end of namespace ROOT
410 
411 namespace ROOT {
412  static TClass *unary_functionlEchar16_tcOunsignedsPlonggR_Dictionary();
413  static void unary_functionlEchar16_tcOunsignedsPlonggR_TClassManip(TClass*);
414  static void *new_unary_functionlEchar16_tcOunsignedsPlonggR(void *p = 0);
415  static void *newArray_unary_functionlEchar16_tcOunsignedsPlonggR(Long_t size, void *p);
416  static void delete_unary_functionlEchar16_tcOunsignedsPlonggR(void *p);
417  static void deleteArray_unary_functionlEchar16_tcOunsignedsPlonggR(void *p);
418  static void destruct_unary_functionlEchar16_tcOunsignedsPlonggR(void *p);
419 
420  // Function generating the singleton type initializer
421  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<char16_t,unsigned long>*)
422  {
423  ::unary_function<char16_t,unsigned long> *ptr = 0;
424  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<char16_t,unsigned long>));
425  static ::ROOT::TGenericClassInfo
426  instance("unary_function<char16_t,unsigned long>", "string", 105,
427  typeid(::unary_function<char16_t,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
428  &unary_functionlEchar16_tcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
429  sizeof(::unary_function<char16_t,unsigned long>) );
430  instance.SetNew(&new_unary_functionlEchar16_tcOunsignedsPlonggR);
431  instance.SetNewArray(&newArray_unary_functionlEchar16_tcOunsignedsPlonggR);
432  instance.SetDelete(&delete_unary_functionlEchar16_tcOunsignedsPlonggR);
433  instance.SetDeleteArray(&deleteArray_unary_functionlEchar16_tcOunsignedsPlonggR);
434  instance.SetDestructor(&destruct_unary_functionlEchar16_tcOunsignedsPlonggR);
435  return &instance;
436  }
437  // Static variable to force the class initialization
438  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<char16_t,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
439 
440  // Dictionary for non-ClassDef classes
441  static TClass *unary_functionlEchar16_tcOunsignedsPlonggR_Dictionary() {
442  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<char16_t,unsigned long>*)0x0)->GetClass();
443  unary_functionlEchar16_tcOunsignedsPlonggR_TClassManip(theClass);
444  return theClass;
445  }
446 
447  static void unary_functionlEchar16_tcOunsignedsPlonggR_TClassManip(TClass* ){
448  }
449 
450 } // end of namespace ROOT
451 
452 namespace ROOT {
453  static TClass *unary_functionlEchar32_tcOunsignedsPlonggR_Dictionary();
454  static void unary_functionlEchar32_tcOunsignedsPlonggR_TClassManip(TClass*);
455  static void *new_unary_functionlEchar32_tcOunsignedsPlonggR(void *p = 0);
456  static void *newArray_unary_functionlEchar32_tcOunsignedsPlonggR(Long_t size, void *p);
457  static void delete_unary_functionlEchar32_tcOunsignedsPlonggR(void *p);
458  static void deleteArray_unary_functionlEchar32_tcOunsignedsPlonggR(void *p);
459  static void destruct_unary_functionlEchar32_tcOunsignedsPlonggR(void *p);
460 
461  // Function generating the singleton type initializer
462  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<char32_t,unsigned long>*)
463  {
464  ::unary_function<char32_t,unsigned long> *ptr = 0;
465  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<char32_t,unsigned long>));
466  static ::ROOT::TGenericClassInfo
467  instance("unary_function<char32_t,unsigned long>", "string", 105,
468  typeid(::unary_function<char32_t,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
469  &unary_functionlEchar32_tcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
470  sizeof(::unary_function<char32_t,unsigned long>) );
471  instance.SetNew(&new_unary_functionlEchar32_tcOunsignedsPlonggR);
472  instance.SetNewArray(&newArray_unary_functionlEchar32_tcOunsignedsPlonggR);
473  instance.SetDelete(&delete_unary_functionlEchar32_tcOunsignedsPlonggR);
474  instance.SetDeleteArray(&deleteArray_unary_functionlEchar32_tcOunsignedsPlonggR);
475  instance.SetDestructor(&destruct_unary_functionlEchar32_tcOunsignedsPlonggR);
476  return &instance;
477  }
478  // Static variable to force the class initialization
479  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<char32_t,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
480 
481  // Dictionary for non-ClassDef classes
482  static TClass *unary_functionlEchar32_tcOunsignedsPlonggR_Dictionary() {
483  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<char32_t,unsigned long>*)0x0)->GetClass();
484  unary_functionlEchar32_tcOunsignedsPlonggR_TClassManip(theClass);
485  return theClass;
486  }
487 
488  static void unary_functionlEchar32_tcOunsignedsPlonggR_TClassManip(TClass* ){
489  }
490 
491 } // end of namespace ROOT
492 
493 namespace ROOT {
494  static TClass *unary_functionlEshortcOunsignedsPlonggR_Dictionary();
495  static void unary_functionlEshortcOunsignedsPlonggR_TClassManip(TClass*);
496  static void *new_unary_functionlEshortcOunsignedsPlonggR(void *p = 0);
497  static void *newArray_unary_functionlEshortcOunsignedsPlonggR(Long_t size, void *p);
498  static void delete_unary_functionlEshortcOunsignedsPlonggR(void *p);
499  static void deleteArray_unary_functionlEshortcOunsignedsPlonggR(void *p);
500  static void destruct_unary_functionlEshortcOunsignedsPlonggR(void *p);
501 
502  // Function generating the singleton type initializer
503  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<short,unsigned long>*)
504  {
505  ::unary_function<short,unsigned long> *ptr = 0;
506  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<short,unsigned long>));
507  static ::ROOT::TGenericClassInfo
508  instance("unary_function<short,unsigned long>", "string", 105,
509  typeid(::unary_function<short,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
510  &unary_functionlEshortcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
511  sizeof(::unary_function<short,unsigned long>) );
512  instance.SetNew(&new_unary_functionlEshortcOunsignedsPlonggR);
513  instance.SetNewArray(&newArray_unary_functionlEshortcOunsignedsPlonggR);
514  instance.SetDelete(&delete_unary_functionlEshortcOunsignedsPlonggR);
515  instance.SetDeleteArray(&deleteArray_unary_functionlEshortcOunsignedsPlonggR);
516  instance.SetDestructor(&destruct_unary_functionlEshortcOunsignedsPlonggR);
517  return &instance;
518  }
519  // Static variable to force the class initialization
520  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<short,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
521 
522  // Dictionary for non-ClassDef classes
523  static TClass *unary_functionlEshortcOunsignedsPlonggR_Dictionary() {
524  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<short,unsigned long>*)0x0)->GetClass();
525  unary_functionlEshortcOunsignedsPlonggR_TClassManip(theClass);
526  return theClass;
527  }
528 
529  static void unary_functionlEshortcOunsignedsPlonggR_TClassManip(TClass* ){
530  }
531 
532 } // end of namespace ROOT
533 
534 namespace ROOT {
535  static TClass *unary_functionlEunsignedsPshortcOunsignedsPlonggR_Dictionary();
536  static void unary_functionlEunsignedsPshortcOunsignedsPlonggR_TClassManip(TClass*);
537  static void *new_unary_functionlEunsignedsPshortcOunsignedsPlonggR(void *p = 0);
538  static void *newArray_unary_functionlEunsignedsPshortcOunsignedsPlonggR(Long_t size, void *p);
539  static void delete_unary_functionlEunsignedsPshortcOunsignedsPlonggR(void *p);
540  static void deleteArray_unary_functionlEunsignedsPshortcOunsignedsPlonggR(void *p);
541  static void destruct_unary_functionlEunsignedsPshortcOunsignedsPlonggR(void *p);
542 
543  // Function generating the singleton type initializer
544  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<unsigned short,unsigned long>*)
545  {
546  ::unary_function<unsigned short,unsigned long> *ptr = 0;
547  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<unsigned short,unsigned long>));
548  static ::ROOT::TGenericClassInfo
549  instance("unary_function<unsigned short,unsigned long>", "string", 105,
550  typeid(::unary_function<unsigned short,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
551  &unary_functionlEunsignedsPshortcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
552  sizeof(::unary_function<unsigned short,unsigned long>) );
553  instance.SetNew(&new_unary_functionlEunsignedsPshortcOunsignedsPlonggR);
554  instance.SetNewArray(&newArray_unary_functionlEunsignedsPshortcOunsignedsPlonggR);
555  instance.SetDelete(&delete_unary_functionlEunsignedsPshortcOunsignedsPlonggR);
556  instance.SetDeleteArray(&deleteArray_unary_functionlEunsignedsPshortcOunsignedsPlonggR);
557  instance.SetDestructor(&destruct_unary_functionlEunsignedsPshortcOunsignedsPlonggR);
558  return &instance;
559  }
560  // Static variable to force the class initialization
561  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<unsigned short,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
562 
563  // Dictionary for non-ClassDef classes
564  static TClass *unary_functionlEunsignedsPshortcOunsignedsPlonggR_Dictionary() {
565  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<unsigned short,unsigned long>*)0x0)->GetClass();
566  unary_functionlEunsignedsPshortcOunsignedsPlonggR_TClassManip(theClass);
567  return theClass;
568  }
569 
570  static void unary_functionlEunsignedsPshortcOunsignedsPlonggR_TClassManip(TClass* ){
571  }
572 
573 } // end of namespace ROOT
574 
575 namespace ROOT {
576  static TClass *unary_functionlEintcOunsignedsPlonggR_Dictionary();
577  static void unary_functionlEintcOunsignedsPlonggR_TClassManip(TClass*);
578  static void *new_unary_functionlEintcOunsignedsPlonggR(void *p = 0);
579  static void *newArray_unary_functionlEintcOunsignedsPlonggR(Long_t size, void *p);
580  static void delete_unary_functionlEintcOunsignedsPlonggR(void *p);
581  static void deleteArray_unary_functionlEintcOunsignedsPlonggR(void *p);
582  static void destruct_unary_functionlEintcOunsignedsPlonggR(void *p);
583 
584  // Function generating the singleton type initializer
585  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<int,unsigned long>*)
586  {
587  ::unary_function<int,unsigned long> *ptr = 0;
588  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<int,unsigned long>));
589  static ::ROOT::TGenericClassInfo
590  instance("unary_function<int,unsigned long>", "string", 105,
591  typeid(::unary_function<int,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
592  &unary_functionlEintcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
593  sizeof(::unary_function<int,unsigned long>) );
594  instance.SetNew(&new_unary_functionlEintcOunsignedsPlonggR);
595  instance.SetNewArray(&newArray_unary_functionlEintcOunsignedsPlonggR);
596  instance.SetDelete(&delete_unary_functionlEintcOunsignedsPlonggR);
597  instance.SetDeleteArray(&deleteArray_unary_functionlEintcOunsignedsPlonggR);
598  instance.SetDestructor(&destruct_unary_functionlEintcOunsignedsPlonggR);
599  return &instance;
600  }
601  // Static variable to force the class initialization
602  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<int,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
603 
604  // Dictionary for non-ClassDef classes
605  static TClass *unary_functionlEintcOunsignedsPlonggR_Dictionary() {
606  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<int,unsigned long>*)0x0)->GetClass();
607  unary_functionlEintcOunsignedsPlonggR_TClassManip(theClass);
608  return theClass;
609  }
610 
611  static void unary_functionlEintcOunsignedsPlonggR_TClassManip(TClass* ){
612  }
613 
614 } // end of namespace ROOT
615 
616 namespace ROOT {
617  static TClass *unary_functionlEunsignedsPintcOunsignedsPlonggR_Dictionary();
618  static void unary_functionlEunsignedsPintcOunsignedsPlonggR_TClassManip(TClass*);
619  static void *new_unary_functionlEunsignedsPintcOunsignedsPlonggR(void *p = 0);
620  static void *newArray_unary_functionlEunsignedsPintcOunsignedsPlonggR(Long_t size, void *p);
621  static void delete_unary_functionlEunsignedsPintcOunsignedsPlonggR(void *p);
622  static void deleteArray_unary_functionlEunsignedsPintcOunsignedsPlonggR(void *p);
623  static void destruct_unary_functionlEunsignedsPintcOunsignedsPlonggR(void *p);
624 
625  // Function generating the singleton type initializer
626  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<unsigned int,unsigned long>*)
627  {
628  ::unary_function<unsigned int,unsigned long> *ptr = 0;
629  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<unsigned int,unsigned long>));
630  static ::ROOT::TGenericClassInfo
631  instance("unary_function<unsigned int,unsigned long>", "string", 105,
632  typeid(::unary_function<unsigned int,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
633  &unary_functionlEunsignedsPintcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
634  sizeof(::unary_function<unsigned int,unsigned long>) );
635  instance.SetNew(&new_unary_functionlEunsignedsPintcOunsignedsPlonggR);
636  instance.SetNewArray(&newArray_unary_functionlEunsignedsPintcOunsignedsPlonggR);
637  instance.SetDelete(&delete_unary_functionlEunsignedsPintcOunsignedsPlonggR);
638  instance.SetDeleteArray(&deleteArray_unary_functionlEunsignedsPintcOunsignedsPlonggR);
639  instance.SetDestructor(&destruct_unary_functionlEunsignedsPintcOunsignedsPlonggR);
640  return &instance;
641  }
642  // Static variable to force the class initialization
643  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<unsigned int,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
644 
645  // Dictionary for non-ClassDef classes
646  static TClass *unary_functionlEunsignedsPintcOunsignedsPlonggR_Dictionary() {
647  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<unsigned int,unsigned long>*)0x0)->GetClass();
648  unary_functionlEunsignedsPintcOunsignedsPlonggR_TClassManip(theClass);
649  return theClass;
650  }
651 
652  static void unary_functionlEunsignedsPintcOunsignedsPlonggR_TClassManip(TClass* ){
653  }
654 
655 } // end of namespace ROOT
656 
657 namespace ROOT {
658  static TClass *unary_functionlElongcOunsignedsPlonggR_Dictionary();
659  static void unary_functionlElongcOunsignedsPlonggR_TClassManip(TClass*);
660  static void *new_unary_functionlElongcOunsignedsPlonggR(void *p = 0);
661  static void *newArray_unary_functionlElongcOunsignedsPlonggR(Long_t size, void *p);
662  static void delete_unary_functionlElongcOunsignedsPlonggR(void *p);
663  static void deleteArray_unary_functionlElongcOunsignedsPlonggR(void *p);
664  static void destruct_unary_functionlElongcOunsignedsPlonggR(void *p);
665 
666  // Function generating the singleton type initializer
667  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<long,unsigned long>*)
668  {
669  ::unary_function<long,unsigned long> *ptr = 0;
670  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<long,unsigned long>));
671  static ::ROOT::TGenericClassInfo
672  instance("unary_function<long,unsigned long>", "string", 105,
673  typeid(::unary_function<long,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
674  &unary_functionlElongcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
675  sizeof(::unary_function<long,unsigned long>) );
676  instance.SetNew(&new_unary_functionlElongcOunsignedsPlonggR);
677  instance.SetNewArray(&newArray_unary_functionlElongcOunsignedsPlonggR);
678  instance.SetDelete(&delete_unary_functionlElongcOunsignedsPlonggR);
679  instance.SetDeleteArray(&deleteArray_unary_functionlElongcOunsignedsPlonggR);
680  instance.SetDestructor(&destruct_unary_functionlElongcOunsignedsPlonggR);
681  return &instance;
682  }
683  // Static variable to force the class initialization
684  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<long,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
685 
686  // Dictionary for non-ClassDef classes
687  static TClass *unary_functionlElongcOunsignedsPlonggR_Dictionary() {
688  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<long,unsigned long>*)0x0)->GetClass();
689  unary_functionlElongcOunsignedsPlonggR_TClassManip(theClass);
690  return theClass;
691  }
692 
693  static void unary_functionlElongcOunsignedsPlonggR_TClassManip(TClass* ){
694  }
695 
696 } // end of namespace ROOT
697 
698 namespace ROOT {
699  static TClass *unary_functionlEunsignedsPlongcOunsignedsPlonggR_Dictionary();
700  static void unary_functionlEunsignedsPlongcOunsignedsPlonggR_TClassManip(TClass*);
701  static void *new_unary_functionlEunsignedsPlongcOunsignedsPlonggR(void *p = 0);
702  static void *newArray_unary_functionlEunsignedsPlongcOunsignedsPlonggR(Long_t size, void *p);
703  static void delete_unary_functionlEunsignedsPlongcOunsignedsPlonggR(void *p);
704  static void deleteArray_unary_functionlEunsignedsPlongcOunsignedsPlonggR(void *p);
705  static void destruct_unary_functionlEunsignedsPlongcOunsignedsPlonggR(void *p);
706 
707  // Function generating the singleton type initializer
708  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<unsigned long,unsigned long>*)
709  {
710  ::unary_function<unsigned long,unsigned long> *ptr = 0;
711  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<unsigned long,unsigned long>));
712  static ::ROOT::TGenericClassInfo
713  instance("unary_function<unsigned long,unsigned long>", "string", 105,
714  typeid(::unary_function<unsigned long,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
715  &unary_functionlEunsignedsPlongcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
716  sizeof(::unary_function<unsigned long,unsigned long>) );
717  instance.SetNew(&new_unary_functionlEunsignedsPlongcOunsignedsPlonggR);
718  instance.SetNewArray(&newArray_unary_functionlEunsignedsPlongcOunsignedsPlonggR);
719  instance.SetDelete(&delete_unary_functionlEunsignedsPlongcOunsignedsPlonggR);
720  instance.SetDeleteArray(&deleteArray_unary_functionlEunsignedsPlongcOunsignedsPlonggR);
721  instance.SetDestructor(&destruct_unary_functionlEunsignedsPlongcOunsignedsPlonggR);
722  return &instance;
723  }
724  // Static variable to force the class initialization
725  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<unsigned long,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
726 
727  // Dictionary for non-ClassDef classes
728  static TClass *unary_functionlEunsignedsPlongcOunsignedsPlonggR_Dictionary() {
729  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<unsigned long,unsigned long>*)0x0)->GetClass();
730  unary_functionlEunsignedsPlongcOunsignedsPlonggR_TClassManip(theClass);
731  return theClass;
732  }
733 
734  static void unary_functionlEunsignedsPlongcOunsignedsPlonggR_TClassManip(TClass* ){
735  }
736 
737 } // end of namespace ROOT
738 
739 namespace ROOT {
740  static TClass *unary_functionlEfloatcOunsignedsPlonggR_Dictionary();
741  static void unary_functionlEfloatcOunsignedsPlonggR_TClassManip(TClass*);
742  static void *new_unary_functionlEfloatcOunsignedsPlonggR(void *p = 0);
743  static void *newArray_unary_functionlEfloatcOunsignedsPlonggR(Long_t size, void *p);
744  static void delete_unary_functionlEfloatcOunsignedsPlonggR(void *p);
745  static void deleteArray_unary_functionlEfloatcOunsignedsPlonggR(void *p);
746  static void destruct_unary_functionlEfloatcOunsignedsPlonggR(void *p);
747 
748  // Function generating the singleton type initializer
749  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<float,unsigned long>*)
750  {
751  ::unary_function<float,unsigned long> *ptr = 0;
752  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<float,unsigned long>));
753  static ::ROOT::TGenericClassInfo
754  instance("unary_function<float,unsigned long>", "string", 105,
755  typeid(::unary_function<float,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
756  &unary_functionlEfloatcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
757  sizeof(::unary_function<float,unsigned long>) );
758  instance.SetNew(&new_unary_functionlEfloatcOunsignedsPlonggR);
759  instance.SetNewArray(&newArray_unary_functionlEfloatcOunsignedsPlonggR);
760  instance.SetDelete(&delete_unary_functionlEfloatcOunsignedsPlonggR);
761  instance.SetDeleteArray(&deleteArray_unary_functionlEfloatcOunsignedsPlonggR);
762  instance.SetDestructor(&destruct_unary_functionlEfloatcOunsignedsPlonggR);
763  return &instance;
764  }
765  // Static variable to force the class initialization
766  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<float,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
767 
768  // Dictionary for non-ClassDef classes
769  static TClass *unary_functionlEfloatcOunsignedsPlonggR_Dictionary() {
770  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<float,unsigned long>*)0x0)->GetClass();
771  unary_functionlEfloatcOunsignedsPlonggR_TClassManip(theClass);
772  return theClass;
773  }
774 
775  static void unary_functionlEfloatcOunsignedsPlonggR_TClassManip(TClass* ){
776  }
777 
778 } // end of namespace ROOT
779 
780 namespace ROOT {
781  static TClass *unary_functionlEdoublecOunsignedsPlonggR_Dictionary();
782  static void unary_functionlEdoublecOunsignedsPlonggR_TClassManip(TClass*);
783  static void *new_unary_functionlEdoublecOunsignedsPlonggR(void *p = 0);
784  static void *newArray_unary_functionlEdoublecOunsignedsPlonggR(Long_t size, void *p);
785  static void delete_unary_functionlEdoublecOunsignedsPlonggR(void *p);
786  static void deleteArray_unary_functionlEdoublecOunsignedsPlonggR(void *p);
787  static void destruct_unary_functionlEdoublecOunsignedsPlonggR(void *p);
788 
789  // Function generating the singleton type initializer
790  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<double,unsigned long>*)
791  {
792  ::unary_function<double,unsigned long> *ptr = 0;
793  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<double,unsigned long>));
794  static ::ROOT::TGenericClassInfo
795  instance("unary_function<double,unsigned long>", "string", 105,
796  typeid(::unary_function<double,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
797  &unary_functionlEdoublecOunsignedsPlonggR_Dictionary, isa_proxy, 4,
798  sizeof(::unary_function<double,unsigned long>) );
799  instance.SetNew(&new_unary_functionlEdoublecOunsignedsPlonggR);
800  instance.SetNewArray(&newArray_unary_functionlEdoublecOunsignedsPlonggR);
801  instance.SetDelete(&delete_unary_functionlEdoublecOunsignedsPlonggR);
802  instance.SetDeleteArray(&deleteArray_unary_functionlEdoublecOunsignedsPlonggR);
803  instance.SetDestructor(&destruct_unary_functionlEdoublecOunsignedsPlonggR);
804  return &instance;
805  }
806  // Static variable to force the class initialization
807  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<double,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
808 
809  // Dictionary for non-ClassDef classes
810  static TClass *unary_functionlEdoublecOunsignedsPlonggR_Dictionary() {
811  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<double,unsigned long>*)0x0)->GetClass();
812  unary_functionlEdoublecOunsignedsPlonggR_TClassManip(theClass);
813  return theClass;
814  }
815 
816  static void unary_functionlEdoublecOunsignedsPlonggR_TClassManip(TClass* ){
817  }
818 
819 } // end of namespace ROOT
820 
821 namespace ROOT {
822  static TClass *unary_functionlElongsPdoublecOunsignedsPlonggR_Dictionary();
823  static void unary_functionlElongsPdoublecOunsignedsPlonggR_TClassManip(TClass*);
824  static void *new_unary_functionlElongsPdoublecOunsignedsPlonggR(void *p = 0);
825  static void *newArray_unary_functionlElongsPdoublecOunsignedsPlonggR(Long_t size, void *p);
826  static void delete_unary_functionlElongsPdoublecOunsignedsPlonggR(void *p);
827  static void deleteArray_unary_functionlElongsPdoublecOunsignedsPlonggR(void *p);
828  static void destruct_unary_functionlElongsPdoublecOunsignedsPlonggR(void *p);
829 
830  // Function generating the singleton type initializer
831  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<long double,unsigned long>*)
832  {
833  ::unary_function<long double,unsigned long> *ptr = 0;
834  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<long double,unsigned long>));
835  static ::ROOT::TGenericClassInfo
836  instance("unary_function<long double,unsigned long>", "string", 105,
837  typeid(::unary_function<long double,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
838  &unary_functionlElongsPdoublecOunsignedsPlonggR_Dictionary, isa_proxy, 4,
839  sizeof(::unary_function<long double,unsigned long>) );
840  instance.SetNew(&new_unary_functionlElongsPdoublecOunsignedsPlonggR);
841  instance.SetNewArray(&newArray_unary_functionlElongsPdoublecOunsignedsPlonggR);
842  instance.SetDelete(&delete_unary_functionlElongsPdoublecOunsignedsPlonggR);
843  instance.SetDeleteArray(&deleteArray_unary_functionlElongsPdoublecOunsignedsPlonggR);
844  instance.SetDestructor(&destruct_unary_functionlElongsPdoublecOunsignedsPlonggR);
845  return &instance;
846  }
847  // Static variable to force the class initialization
848  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<long double,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
849 
850  // Dictionary for non-ClassDef classes
851  static TClass *unary_functionlElongsPdoublecOunsignedsPlonggR_Dictionary() {
852  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<long double,unsigned long>*)0x0)->GetClass();
853  unary_functionlElongsPdoublecOunsignedsPlonggR_TClassManip(theClass);
854  return theClass;
855  }
856 
857  static void unary_functionlElongsPdoublecOunsignedsPlonggR_TClassManip(TClass* ){
858  }
859 
860 } // end of namespace ROOT
861 
862 namespace ROOT {
863  static TClass *unary_functionlEstringcOunsignedsPlonggR_Dictionary();
864  static void unary_functionlEstringcOunsignedsPlonggR_TClassManip(TClass*);
865  static void *new_unary_functionlEstringcOunsignedsPlonggR(void *p = 0);
866  static void *newArray_unary_functionlEstringcOunsignedsPlonggR(Long_t size, void *p);
867  static void delete_unary_functionlEstringcOunsignedsPlonggR(void *p);
868  static void deleteArray_unary_functionlEstringcOunsignedsPlonggR(void *p);
869  static void destruct_unary_functionlEstringcOunsignedsPlonggR(void *p);
870 
871  // Function generating the singleton type initializer
872  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<string,unsigned long>*)
873  {
874  ::unary_function<string,unsigned long> *ptr = 0;
875  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<string,unsigned long>));
876  static ::ROOT::TGenericClassInfo
877  instance("unary_function<string,unsigned long>", "string", 105,
878  typeid(::unary_function<string,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
879  &unary_functionlEstringcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
880  sizeof(::unary_function<string,unsigned long>) );
881  instance.SetNew(&new_unary_functionlEstringcOunsignedsPlonggR);
882  instance.SetNewArray(&newArray_unary_functionlEstringcOunsignedsPlonggR);
883  instance.SetDelete(&delete_unary_functionlEstringcOunsignedsPlonggR);
884  instance.SetDeleteArray(&deleteArray_unary_functionlEstringcOunsignedsPlonggR);
885  instance.SetDestructor(&destruct_unary_functionlEstringcOunsignedsPlonggR);
886  return &instance;
887  }
888  // Static variable to force the class initialization
889  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<string,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
890 
891  // Dictionary for non-ClassDef classes
892  static TClass *unary_functionlEstringcOunsignedsPlonggR_Dictionary() {
893  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<string,unsigned long>*)0x0)->GetClass();
894  unary_functionlEstringcOunsignedsPlonggR_TClassManip(theClass);
895  return theClass;
896  }
897 
898  static void unary_functionlEstringcOunsignedsPlonggR_TClassManip(TClass* ){
899  }
900 
901 } // end of namespace ROOT
902 
903 namespace ROOT {
904  static TClass *unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR_Dictionary();
905  static void unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR_TClassManip(TClass*);
906  static void *new_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR(void *p = 0);
907  static void *newArray_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR(Long_t size, void *p);
908  static void delete_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR(void *p);
909  static void deleteArray_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR(void *p);
910  static void destruct_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR(void *p);
911 
912  // Function generating the singleton type initializer
913  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>*)
914  {
915  ::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long> *ptr = 0;
916  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>));
917  static ::ROOT::TGenericClassInfo
918  instance("unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>", "string", 105,
919  typeid(::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
920  &unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
921  sizeof(::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>) );
922  instance.SetNew(&new_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR);
923  instance.SetNewArray(&newArray_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR);
924  instance.SetDelete(&delete_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR);
925  instance.SetDeleteArray(&deleteArray_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR);
926  instance.SetDestructor(&destruct_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR);
927  return &instance;
928  }
929  // Static variable to force the class initialization
930  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
931 
932  // Dictionary for non-ClassDef classes
933  static TClass *unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR_Dictionary() {
934  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>*)0x0)->GetClass();
935  unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR_TClassManip(theClass);
936  return theClass;
937  }
938 
939  static void unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR_TClassManip(TClass* ){
940  }
941 
942 } // end of namespace ROOT
943 
944 namespace ROOT {
945  static TClass *unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR_Dictionary();
946  static void unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR_TClassManip(TClass*);
947  static void *new_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR(void *p = 0);
948  static void *newArray_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR(Long_t size, void *p);
949  static void delete_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR(void *p);
950  static void deleteArray_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR(void *p);
951  static void destruct_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR(void *p);
952 
953  // Function generating the singleton type initializer
954  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>*)
955  {
956  ::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long> *ptr = 0;
957  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>));
958  static ::ROOT::TGenericClassInfo
959  instance("unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>", "string", 105,
960  typeid(::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
961  &unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
962  sizeof(::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>) );
963  instance.SetNew(&new_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR);
964  instance.SetNewArray(&newArray_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR);
965  instance.SetDelete(&delete_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR);
966  instance.SetDeleteArray(&deleteArray_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR);
967  instance.SetDestructor(&destruct_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR);
968  return &instance;
969  }
970  // Static variable to force the class initialization
971  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
972 
973  // Dictionary for non-ClassDef classes
974  static TClass *unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR_Dictionary() {
975  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>*)0x0)->GetClass();
976  unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR_TClassManip(theClass);
977  return theClass;
978  }
979 
980  static void unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR_TClassManip(TClass* ){
981  }
982 
983 } // end of namespace ROOT
984 
985 namespace ROOT {
986  static TClass *unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR_Dictionary();
987  static void unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR_TClassManip(TClass*);
988  static void *new_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR(void *p = 0);
989  static void *newArray_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR(Long_t size, void *p);
990  static void delete_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR(void *p);
991  static void deleteArray_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR(void *p);
992  static void destruct_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR(void *p);
993 
994  // Function generating the singleton type initializer
995  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>*)
996  {
997  ::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long> *ptr = 0;
998  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>));
999  static ::ROOT::TGenericClassInfo
1000  instance("unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>", "string", 105,
1001  typeid(::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1002  &unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
1003  sizeof(::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>) );
1004  instance.SetNew(&new_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR);
1005  instance.SetNewArray(&newArray_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR);
1006  instance.SetDelete(&delete_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR);
1007  instance.SetDeleteArray(&deleteArray_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR);
1008  instance.SetDestructor(&destruct_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR);
1009  return &instance;
1010  }
1011  // Static variable to force the class initialization
1012  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1013 
1014  // Dictionary for non-ClassDef classes
1015  static TClass *unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR_Dictionary() {
1016  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>*)0x0)->GetClass();
1017  unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR_TClassManip(theClass);
1018  return theClass;
1019  }
1020 
1021  static void unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR_TClassManip(TClass* ){
1022  }
1023 
1024 } // end of namespace ROOT
1025 
1026 namespace ROOT {
1027  static TClass *unary_functionlELong64_tcOunsignedsPlonggR_Dictionary();
1028  static void unary_functionlELong64_tcOunsignedsPlonggR_TClassManip(TClass*);
1029  static void *new_unary_functionlELong64_tcOunsignedsPlonggR(void *p = 0);
1030  static void *newArray_unary_functionlELong64_tcOunsignedsPlonggR(Long_t size, void *p);
1031  static void delete_unary_functionlELong64_tcOunsignedsPlonggR(void *p);
1032  static void deleteArray_unary_functionlELong64_tcOunsignedsPlonggR(void *p);
1033  static void destruct_unary_functionlELong64_tcOunsignedsPlonggR(void *p);
1034 
1035  // Function generating the singleton type initializer
1036  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<Long64_t,unsigned long>*)
1037  {
1038  ::unary_function<Long64_t,unsigned long> *ptr = 0;
1039  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<Long64_t,unsigned long>));
1040  static ::ROOT::TGenericClassInfo
1041  instance("unary_function<Long64_t,unsigned long>", "string", 105,
1042  typeid(::unary_function<Long64_t,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1043  &unary_functionlELong64_tcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
1044  sizeof(::unary_function<Long64_t,unsigned long>) );
1045  instance.SetNew(&new_unary_functionlELong64_tcOunsignedsPlonggR);
1046  instance.SetNewArray(&newArray_unary_functionlELong64_tcOunsignedsPlonggR);
1047  instance.SetDelete(&delete_unary_functionlELong64_tcOunsignedsPlonggR);
1048  instance.SetDeleteArray(&deleteArray_unary_functionlELong64_tcOunsignedsPlonggR);
1049  instance.SetDestructor(&destruct_unary_functionlELong64_tcOunsignedsPlonggR);
1050  return &instance;
1051  }
1052  // Static variable to force the class initialization
1053  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<Long64_t,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1054 
1055  // Dictionary for non-ClassDef classes
1056  static TClass *unary_functionlELong64_tcOunsignedsPlonggR_Dictionary() {
1057  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<Long64_t,unsigned long>*)0x0)->GetClass();
1058  unary_functionlELong64_tcOunsignedsPlonggR_TClassManip(theClass);
1059  return theClass;
1060  }
1061 
1062  static void unary_functionlELong64_tcOunsignedsPlonggR_TClassManip(TClass* ){
1063  }
1064 
1065 } // end of namespace ROOT
1066 
1067 namespace ROOT {
1068  static TClass *unary_functionlEULong64_tcOunsignedsPlonggR_Dictionary();
1069  static void unary_functionlEULong64_tcOunsignedsPlonggR_TClassManip(TClass*);
1070  static void *new_unary_functionlEULong64_tcOunsignedsPlonggR(void *p = 0);
1071  static void *newArray_unary_functionlEULong64_tcOunsignedsPlonggR(Long_t size, void *p);
1072  static void delete_unary_functionlEULong64_tcOunsignedsPlonggR(void *p);
1073  static void deleteArray_unary_functionlEULong64_tcOunsignedsPlonggR(void *p);
1074  static void destruct_unary_functionlEULong64_tcOunsignedsPlonggR(void *p);
1075 
1076  // Function generating the singleton type initializer
1077  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<ULong64_t,unsigned long>*)
1078  {
1079  ::unary_function<ULong64_t,unsigned long> *ptr = 0;
1080  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<ULong64_t,unsigned long>));
1081  static ::ROOT::TGenericClassInfo
1082  instance("unary_function<ULong64_t,unsigned long>", "string", 105,
1083  typeid(::unary_function<ULong64_t,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1084  &unary_functionlEULong64_tcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
1085  sizeof(::unary_function<ULong64_t,unsigned long>) );
1086  instance.SetNew(&new_unary_functionlEULong64_tcOunsignedsPlonggR);
1087  instance.SetNewArray(&newArray_unary_functionlEULong64_tcOunsignedsPlonggR);
1088  instance.SetDelete(&delete_unary_functionlEULong64_tcOunsignedsPlonggR);
1089  instance.SetDeleteArray(&deleteArray_unary_functionlEULong64_tcOunsignedsPlonggR);
1090  instance.SetDestructor(&destruct_unary_functionlEULong64_tcOunsignedsPlonggR);
1091  return &instance;
1092  }
1093  // Static variable to force the class initialization
1094  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<ULong64_t,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1095 
1096  // Dictionary for non-ClassDef classes
1097  static TClass *unary_functionlEULong64_tcOunsignedsPlonggR_Dictionary() {
1098  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<ULong64_t,unsigned long>*)0x0)->GetClass();
1099  unary_functionlEULong64_tcOunsignedsPlonggR_TClassManip(theClass);
1100  return theClass;
1101  }
1102 
1103  static void unary_functionlEULong64_tcOunsignedsPlonggR_TClassManip(TClass* ){
1104  }
1105 
1106 } // end of namespace ROOT
1107 
1108 namespace ROOT {
1109  static TClass *unary_functionlEtype_indexcOunsignedsPlonggR_Dictionary();
1110  static void unary_functionlEtype_indexcOunsignedsPlonggR_TClassManip(TClass*);
1111  static void *new_unary_functionlEtype_indexcOunsignedsPlonggR(void *p = 0);
1112  static void *newArray_unary_functionlEtype_indexcOunsignedsPlonggR(Long_t size, void *p);
1113  static void delete_unary_functionlEtype_indexcOunsignedsPlonggR(void *p);
1114  static void deleteArray_unary_functionlEtype_indexcOunsignedsPlonggR(void *p);
1115  static void destruct_unary_functionlEtype_indexcOunsignedsPlonggR(void *p);
1116 
1117  // Function generating the singleton type initializer
1118  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<type_index,unsigned long>*)
1119  {
1120  ::unary_function<type_index,unsigned long> *ptr = 0;
1121  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<type_index,unsigned long>));
1122  static ::ROOT::TGenericClassInfo
1123  instance("unary_function<type_index,unsigned long>", "string", 105,
1124  typeid(::unary_function<type_index,unsigned long>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1125  &unary_functionlEtype_indexcOunsignedsPlonggR_Dictionary, isa_proxy, 4,
1126  sizeof(::unary_function<type_index,unsigned long>) );
1127  instance.SetNew(&new_unary_functionlEtype_indexcOunsignedsPlonggR);
1128  instance.SetNewArray(&newArray_unary_functionlEtype_indexcOunsignedsPlonggR);
1129  instance.SetDelete(&delete_unary_functionlEtype_indexcOunsignedsPlonggR);
1130  instance.SetDeleteArray(&deleteArray_unary_functionlEtype_indexcOunsignedsPlonggR);
1131  instance.SetDestructor(&destruct_unary_functionlEtype_indexcOunsignedsPlonggR);
1132  return &instance;
1133  }
1134  // Static variable to force the class initialization
1135  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<type_index,unsigned long>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1136 
1137  // Dictionary for non-ClassDef classes
1138  static TClass *unary_functionlEtype_indexcOunsignedsPlonggR_Dictionary() {
1139  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<type_index,unsigned long>*)0x0)->GetClass();
1140  unary_functionlEtype_indexcOunsignedsPlonggR_TClassManip(theClass);
1141  return theClass;
1142  }
1143 
1144  static void unary_functionlEtype_indexcOunsignedsPlonggR_TClassManip(TClass* ){
1145  }
1146 
1147 } // end of namespace ROOT
1148 
1149 namespace ROOT {
1150  static TClass *unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR_Dictionary();
1151  static void unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR_TClassManip(TClass*);
1152  static void *new_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR(void *p = 0);
1153  static void *newArray_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR(Long_t size, void *p);
1154  static void delete_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR(void *p);
1155  static void deleteArray_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR(void *p);
1156  static void destruct_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR(void *p);
1157 
1158  // Function generating the singleton type initializer
1159  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<Gaudi::Details::PropertyBase&,void>*)
1160  {
1161  ::unary_function<Gaudi::Details::PropertyBase&,void> *ptr = 0;
1162  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<Gaudi::Details::PropertyBase&,void>));
1163  static ::ROOT::TGenericClassInfo
1164  instance("unary_function<Gaudi::Details::PropertyBase&,void>", "string", 105,
1165  typeid(::unary_function<Gaudi::Details::PropertyBase&,void>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1166  &unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR_Dictionary, isa_proxy, 4,
1167  sizeof(::unary_function<Gaudi::Details::PropertyBase&,void>) );
1168  instance.SetNew(&new_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR);
1169  instance.SetNewArray(&newArray_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR);
1170  instance.SetDelete(&delete_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR);
1171  instance.SetDeleteArray(&deleteArray_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR);
1172  instance.SetDestructor(&destruct_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR);
1173  return &instance;
1174  }
1175  // Static variable to force the class initialization
1176  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<Gaudi::Details::PropertyBase&,void>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1177 
1178  // Dictionary for non-ClassDef classes
1179  static TClass *unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR_Dictionary() {
1180  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<Gaudi::Details::PropertyBase&,void>*)0x0)->GetClass();
1181  unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR_TClassManip(theClass);
1182  return theClass;
1183  }
1184 
1185  static void unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR_TClassManip(TClass* ){
1186  }
1187 
1188 } // end of namespace ROOT
1189 
1190 namespace ROOT {
1191  static TClass *unary_functionlEconstsPIInterfacemUcOIInterfacemUgR_Dictionary();
1192  static void unary_functionlEconstsPIInterfacemUcOIInterfacemUgR_TClassManip(TClass*);
1193  static void *new_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR(void *p = 0);
1194  static void *newArray_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR(Long_t size, void *p);
1195  static void delete_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR(void *p);
1196  static void deleteArray_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR(void *p);
1197  static void destruct_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR(void *p);
1198 
1199  // Function generating the singleton type initializer
1200  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<const IInterface*,IInterface*>*)
1201  {
1202  ::unary_function<const IInterface*,IInterface*> *ptr = 0;
1203  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<const IInterface*,IInterface*>));
1204  static ::ROOT::TGenericClassInfo
1205  instance("unary_function<const IInterface*,IInterface*>", "string", 105,
1206  typeid(::unary_function<const IInterface*,IInterface*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1207  &unary_functionlEconstsPIInterfacemUcOIInterfacemUgR_Dictionary, isa_proxy, 4,
1208  sizeof(::unary_function<const IInterface*,IInterface*>) );
1209  instance.SetNew(&new_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR);
1210  instance.SetNewArray(&newArray_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR);
1211  instance.SetDelete(&delete_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR);
1212  instance.SetDeleteArray(&deleteArray_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR);
1213  instance.SetDestructor(&destruct_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR);
1214  return &instance;
1215  }
1216  // Static variable to force the class initialization
1217  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<const IInterface*,IInterface*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1218 
1219  // Dictionary for non-ClassDef classes
1220  static TClass *unary_functionlEconstsPIInterfacemUcOIInterfacemUgR_Dictionary() {
1221  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<const IInterface*,IInterface*>*)0x0)->GetClass();
1222  unary_functionlEconstsPIInterfacemUcOIInterfacemUgR_TClassManip(theClass);
1223  return theClass;
1224  }
1225 
1226  static void unary_functionlEconstsPIInterfacemUcOIInterfacemUgR_TClassManip(TClass* ){
1227  }
1228 
1229 } // end of namespace ROOT
1230 
1231 namespace ROOT {
1232  static TClass *unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR_Dictionary();
1233  static void unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR_TClassManip(TClass*);
1234  static void *new_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR(void *p = 0);
1235  static void *newArray_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR(Long_t size, void *p);
1236  static void delete_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR(void *p);
1237  static void deleteArray_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR(void *p);
1238  static void destruct_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR(void *p);
1239 
1240  // Function generating the singleton type initializer
1241  static TGenericClassInfo *GenerateInitInstanceLocal(const ::unary_function<pair<const string,string>,const string>*)
1242  {
1243  ::unary_function<pair<const string,string>,const string> *ptr = 0;
1244  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::unary_function<pair<const string,string>,const string>));
1245  static ::ROOT::TGenericClassInfo
1246  instance("unary_function<pair<const string,string>,const string>", "string", 105,
1247  typeid(::unary_function<pair<const string,string>,const string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1248  &unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR_Dictionary, isa_proxy, 4,
1249  sizeof(::unary_function<pair<const string,string>,const string>) );
1250  instance.SetNew(&new_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR);
1251  instance.SetNewArray(&newArray_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR);
1252  instance.SetDelete(&delete_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR);
1253  instance.SetDeleteArray(&deleteArray_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR);
1254  instance.SetDestructor(&destruct_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR);
1255  return &instance;
1256  }
1257  // Static variable to force the class initialization
1258  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::unary_function<pair<const string,string>,const string>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1259 
1260  // Dictionary for non-ClassDef classes
1261  static TClass *unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR_Dictionary() {
1262  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::unary_function<pair<const string,string>,const string>*)0x0)->GetClass();
1263  unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR_TClassManip(theClass);
1264  return theClass;
1265  }
1266 
1267  static void unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR_TClassManip(TClass* ){
1268  }
1269 
1270 } // end of namespace ROOT
1271 
1272 namespace ROOT {
1273  static TClass *_Bit_reference_Dictionary();
1274  static void _Bit_reference_TClassManip(TClass*);
1275  static void *new__Bit_reference(void *p = 0);
1276  static void *newArray__Bit_reference(Long_t size, void *p);
1277  static void delete__Bit_reference(void *p);
1278  static void deleteArray__Bit_reference(void *p);
1279  static void destruct__Bit_reference(void *p);
1280 
1281  // Function generating the singleton type initializer
1282  static TGenericClassInfo *GenerateInitInstanceLocal(const ::_Bit_reference*)
1283  {
1284  ::_Bit_reference *ptr = 0;
1285  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::_Bit_reference));
1286  static ::ROOT::TGenericClassInfo
1287  instance("_Bit_reference", "vector", 70,
1288  typeid(::_Bit_reference), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1289  &_Bit_reference_Dictionary, isa_proxy, 4,
1290  sizeof(::_Bit_reference) );
1291  instance.SetNew(&new__Bit_reference);
1292  instance.SetNewArray(&newArray__Bit_reference);
1293  instance.SetDelete(&delete__Bit_reference);
1294  instance.SetDeleteArray(&deleteArray__Bit_reference);
1295  instance.SetDestructor(&destruct__Bit_reference);
1296  return &instance;
1297  }
1298  // Static variable to force the class initialization
1299  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::_Bit_reference*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1300 
1301  // Dictionary for non-ClassDef classes
1302  static TClass *_Bit_reference_Dictionary() {
1303  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::_Bit_reference*)0x0)->GetClass();
1304  _Bit_reference_TClassManip(theClass);
1305  return theClass;
1306  }
1307 
1308  static void _Bit_reference_TClassManip(TClass* ){
1309  }
1310 
1311 } // end of namespace ROOT
1312 
1313 namespace ROOT {
1314  static TClass *basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_Dictionary();
1315  static void basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_TClassManip(TClass*);
1316  static void *new_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p = 0);
1317  static void *newArray_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(Long_t size, void *p);
1318  static void delete_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p);
1319  static void deleteArray_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p);
1320  static void destruct_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p);
1321 
1322  // Function generating the singleton type initializer
1323  static TGenericClassInfo *GenerateInitInstanceLocal(const ::basic_stringbuf<char,char_traits<char>,allocator<char> >*)
1324  {
1325  ::basic_stringbuf<char,char_traits<char>,allocator<char> > *ptr = 0;
1326  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::basic_stringbuf<char,char_traits<char>,allocator<char> >));
1327  static ::ROOT::TGenericClassInfo
1328  instance("basic_stringbuf<char,char_traits<char>,allocator<char> >", "sstream", 272,
1329  typeid(::basic_stringbuf<char,char_traits<char>,allocator<char> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1330  &basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_Dictionary, isa_proxy, 4,
1331  sizeof(::basic_stringbuf<char,char_traits<char>,allocator<char> >) );
1332  instance.SetNew(&new_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
1333  instance.SetNewArray(&newArray_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
1334  instance.SetDelete(&delete_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
1335  instance.SetDeleteArray(&deleteArray_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
1336  instance.SetDestructor(&destruct_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
1337 
1338  ::ROOT::AddClassAlternate("basic_stringbuf<char,char_traits<char>,allocator<char> >","basic_stringbuf<char,std::char_traits<char>,std::allocator<char> >");
1339  return &instance;
1340  }
1341  // Static variable to force the class initialization
1342  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::basic_stringbuf<char,char_traits<char>,allocator<char> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1343 
1344  // Dictionary for non-ClassDef classes
1345  static TClass *basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_Dictionary() {
1346  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::basic_stringbuf<char,char_traits<char>,allocator<char> >*)0x0)->GetClass();
1347  basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_TClassManip(theClass);
1348  return theClass;
1349  }
1350 
1351  static void basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_TClassManip(TClass* ){
1352  }
1353 
1354 } // end of namespace ROOT
1355 
1356 namespace ROOT {
1357  static TClass *GaudicLcLUtilscLcLMapBase_Dictionary();
1358  static void GaudicLcLUtilscLcLMapBase_TClassManip(TClass*);
1359  static void *new_GaudicLcLUtilscLcLMapBase(void *p = 0);
1360  static void *newArray_GaudicLcLUtilscLcLMapBase(Long_t size, void *p);
1361  static void delete_GaudicLcLUtilscLcLMapBase(void *p);
1362  static void deleteArray_GaudicLcLUtilscLcLMapBase(void *p);
1363  static void destruct_GaudicLcLUtilscLcLMapBase(void *p);
1364 
1365  // Function generating the singleton type initializer
1366  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Utils::MapBase*)
1367  {
1368  ::Gaudi::Utils::MapBase *ptr = 0;
1369  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Utils::MapBase));
1370  static ::ROOT::TGenericClassInfo
1371  instance("Gaudi::Utils::MapBase", "GaudiKernel/MapBase.h", 44,
1372  typeid(::Gaudi::Utils::MapBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1373  &GaudicLcLUtilscLcLMapBase_Dictionary, isa_proxy, 4,
1374  sizeof(::Gaudi::Utils::MapBase) );
1375  instance.SetNew(&new_GaudicLcLUtilscLcLMapBase);
1376  instance.SetNewArray(&newArray_GaudicLcLUtilscLcLMapBase);
1377  instance.SetDelete(&delete_GaudicLcLUtilscLcLMapBase);
1378  instance.SetDeleteArray(&deleteArray_GaudicLcLUtilscLcLMapBase);
1379  instance.SetDestructor(&destruct_GaudicLcLUtilscLcLMapBase);
1380  return &instance;
1381  }
1382  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Utils::MapBase*)
1383  {
1384  return GenerateInitInstanceLocal((::Gaudi::Utils::MapBase*)0);
1385  }
1386  // Static variable to force the class initialization
1387  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Utils::MapBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1388 
1389  // Dictionary for non-ClassDef classes
1390  static TClass *GaudicLcLUtilscLcLMapBase_Dictionary() {
1391  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Utils::MapBase*)0x0)->GetClass();
1392  GaudicLcLUtilscLcLMapBase_TClassManip(theClass);
1393  return theClass;
1394  }
1395 
1396  static void GaudicLcLUtilscLcLMapBase_TClassManip(TClass* ){
1397  }
1398 
1399 } // end of namespace ROOT
1400 
1401 namespace ROOT {
1402  static TClass *GaudicLcLStringKey_Dictionary();
1403  static void GaudicLcLStringKey_TClassManip(TClass*);
1404  static void *new_GaudicLcLStringKey(void *p = 0);
1405  static void *newArray_GaudicLcLStringKey(Long_t size, void *p);
1406  static void delete_GaudicLcLStringKey(void *p);
1407  static void deleteArray_GaudicLcLStringKey(void *p);
1408  static void destruct_GaudicLcLStringKey(void *p);
1409 
1410  // Function generating the singleton type initializer
1411  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::StringKey*)
1412  {
1413  ::Gaudi::StringKey *ptr = 0;
1414  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::StringKey));
1415  static ::ROOT::TGenericClassInfo
1416  instance("Gaudi::StringKey", "GaudiKernel/StringKey.h", 35,
1417  typeid(::Gaudi::StringKey), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1418  &GaudicLcLStringKey_Dictionary, isa_proxy, 4,
1419  sizeof(::Gaudi::StringKey) );
1420  instance.SetNew(&new_GaudicLcLStringKey);
1421  instance.SetNewArray(&newArray_GaudicLcLStringKey);
1422  instance.SetDelete(&delete_GaudicLcLStringKey);
1423  instance.SetDeleteArray(&deleteArray_GaudicLcLStringKey);
1424  instance.SetDestructor(&destruct_GaudicLcLStringKey);
1425  return &instance;
1426  }
1427  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::StringKey*)
1428  {
1429  return GenerateInitInstanceLocal((::Gaudi::StringKey*)0);
1430  }
1431  // Static variable to force the class initialization
1432  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::StringKey*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1433 
1434  // Dictionary for non-ClassDef classes
1435  static TClass *GaudicLcLStringKey_Dictionary() {
1436  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::StringKey*)0x0)->GetClass();
1437  GaudicLcLStringKey_TClassManip(theClass);
1438  return theClass;
1439  }
1440 
1441  static void GaudicLcLStringKey_TClassManip(TClass* ){
1442  }
1443 
1444 } // end of namespace ROOT
1445 
1446 namespace ROOT {
1447  static TClass *StatEntity_Dictionary();
1448  static void StatEntity_TClassManip(TClass*);
1449  static void *new_StatEntity(void *p = 0);
1450  static void *newArray_StatEntity(Long_t size, void *p);
1451  static void delete_StatEntity(void *p);
1452  static void deleteArray_StatEntity(void *p);
1453  static void destruct_StatEntity(void *p);
1454 
1455  // Function generating the singleton type initializer
1456  static TGenericClassInfo *GenerateInitInstanceLocal(const ::StatEntity*)
1457  {
1458  ::StatEntity *ptr = 0;
1459  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::StatEntity));
1460  static ::ROOT::TGenericClassInfo
1461  instance("StatEntity", "GaudiKernel/StatEntity.h", 65,
1462  typeid(::StatEntity), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1463  &StatEntity_Dictionary, isa_proxy, 4,
1464  sizeof(::StatEntity) );
1465  instance.SetNew(&new_StatEntity);
1466  instance.SetNewArray(&newArray_StatEntity);
1467  instance.SetDelete(&delete_StatEntity);
1468  instance.SetDeleteArray(&deleteArray_StatEntity);
1469  instance.SetDestructor(&destruct_StatEntity);
1470  return &instance;
1471  }
1472  TGenericClassInfo *GenerateInitInstance(const ::StatEntity*)
1473  {
1474  return GenerateInitInstanceLocal((::StatEntity*)0);
1475  }
1476  // Static variable to force the class initialization
1477  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::StatEntity*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1478 
1479  // Dictionary for non-ClassDef classes
1480  static TClass *StatEntity_Dictionary() {
1481  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::StatEntity*)0x0)->GetClass();
1482  StatEntity_TClassManip(theClass);
1483  return theClass;
1484  }
1485 
1486  static void StatEntity_TClassManip(TClass* ){
1487  }
1488 
1489 } // end of namespace ROOT
1490 
1491 namespace ROOT {
1492  static TClass *ChronoEntity_Dictionary();
1493  static void ChronoEntity_TClassManip(TClass*);
1494  static void *new_ChronoEntity(void *p = 0);
1495  static void *newArray_ChronoEntity(Long_t size, void *p);
1496  static void delete_ChronoEntity(void *p);
1497  static void deleteArray_ChronoEntity(void *p);
1498  static void destruct_ChronoEntity(void *p);
1499 
1500  // Function generating the singleton type initializer
1501  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ChronoEntity*)
1502  {
1503  ::ChronoEntity *ptr = 0;
1504  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ChronoEntity));
1505  static ::ROOT::TGenericClassInfo
1506  instance("ChronoEntity", "GaudiKernel/ChronoEntity.h", 21,
1507  typeid(::ChronoEntity), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1508  &ChronoEntity_Dictionary, isa_proxy, 4,
1509  sizeof(::ChronoEntity) );
1510  instance.SetNew(&new_ChronoEntity);
1511  instance.SetNewArray(&newArray_ChronoEntity);
1512  instance.SetDelete(&delete_ChronoEntity);
1513  instance.SetDeleteArray(&deleteArray_ChronoEntity);
1514  instance.SetDestructor(&destruct_ChronoEntity);
1515  return &instance;
1516  }
1517  TGenericClassInfo *GenerateInitInstance(const ::ChronoEntity*)
1518  {
1519  return GenerateInitInstanceLocal((::ChronoEntity*)0);
1520  }
1521  // Static variable to force the class initialization
1522  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ChronoEntity*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1523 
1524  // Dictionary for non-ClassDef classes
1525  static TClass *ChronoEntity_Dictionary() {
1526  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ChronoEntity*)0x0)->GetClass();
1527  ChronoEntity_TClassManip(theClass);
1528  return theClass;
1529  }
1530 
1531  static void ChronoEntity_TClassManip(TClass* ){
1532  }
1533 
1534 } // end of namespace ROOT
1535 
1536 namespace ROOT {
1537  static TClass *Chrono_Dictionary();
1538  static void Chrono_TClassManip(TClass*);
1539  static void *new_Chrono(void *p = 0);
1540  static void *newArray_Chrono(Long_t size, void *p);
1541  static void delete_Chrono(void *p);
1542  static void deleteArray_Chrono(void *p);
1543  static void destruct_Chrono(void *p);
1544 
1545  // Function generating the singleton type initializer
1546  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Chrono*)
1547  {
1548  ::Chrono *ptr = 0;
1549  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Chrono));
1550  static ::ROOT::TGenericClassInfo
1551  instance("Chrono", "GaudiKernel/Chrono.h", 25,
1552  typeid(::Chrono), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1553  &Chrono_Dictionary, isa_proxy, 4,
1554  sizeof(::Chrono) );
1555  instance.SetNew(&new_Chrono);
1556  instance.SetNewArray(&newArray_Chrono);
1557  instance.SetDelete(&delete_Chrono);
1558  instance.SetDeleteArray(&deleteArray_Chrono);
1559  instance.SetDestructor(&destruct_Chrono);
1560  return &instance;
1561  }
1562  TGenericClassInfo *GenerateInitInstance(const ::Chrono*)
1563  {
1564  return GenerateInitInstanceLocal((::Chrono*)0);
1565  }
1566  // Static variable to force the class initialization
1567  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Chrono*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1568 
1569  // Dictionary for non-ClassDef classes
1570  static TClass *Chrono_Dictionary() {
1571  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Chrono*)0x0)->GetClass();
1572  Chrono_TClassManip(theClass);
1573  return theClass;
1574  }
1575 
1576  static void Chrono_TClassManip(TClass* ){
1577  }
1578 
1579 } // end of namespace ROOT
1580 
1581 namespace ROOT {
1582  static TClass *ParticleProperty_Dictionary();
1583  static void ParticleProperty_TClassManip(TClass*);
1584  static void *new_ParticleProperty(void *p = 0);
1585  static void *newArray_ParticleProperty(Long_t size, void *p);
1586  static void delete_ParticleProperty(void *p);
1587  static void deleteArray_ParticleProperty(void *p);
1588  static void destruct_ParticleProperty(void *p);
1589 
1590  // Function generating the singleton type initializer
1591  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ParticleProperty*)
1592  {
1593  ::ParticleProperty *ptr = 0;
1594  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ParticleProperty));
1595  static ::ROOT::TGenericClassInfo
1596  instance("ParticleProperty", "GaudiKernel/ParticleProperty.h", 18,
1597  typeid(::ParticleProperty), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1598  &ParticleProperty_Dictionary, isa_proxy, 4,
1599  sizeof(::ParticleProperty) );
1600  instance.SetNew(&new_ParticleProperty);
1601  instance.SetNewArray(&newArray_ParticleProperty);
1602  instance.SetDelete(&delete_ParticleProperty);
1603  instance.SetDeleteArray(&deleteArray_ParticleProperty);
1604  instance.SetDestructor(&destruct_ParticleProperty);
1605  return &instance;
1606  }
1607  TGenericClassInfo *GenerateInitInstance(const ::ParticleProperty*)
1608  {
1609  return GenerateInitInstanceLocal((::ParticleProperty*)0);
1610  }
1611  // Static variable to force the class initialization
1612  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ParticleProperty*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1613 
1614  // Dictionary for non-ClassDef classes
1615  static TClass *ParticleProperty_Dictionary() {
1616  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ParticleProperty*)0x0)->GetClass();
1617  ParticleProperty_TClassManip(theClass);
1618  return theClass;
1619  }
1620 
1621  static void ParticleProperty_TClassManip(TClass* ){
1622  }
1623 
1624 } // end of namespace ROOT
1625 
1626 namespace ROOT {
1627  static TClass *GaudicLcLRangeBase__Dictionary();
1628  static void GaudicLcLRangeBase__TClassManip(TClass*);
1629  static void *new_GaudicLcLRangeBase_(void *p = 0);
1630  static void *newArray_GaudicLcLRangeBase_(Long_t size, void *p);
1631  static void delete_GaudicLcLRangeBase_(void *p);
1632  static void deleteArray_GaudicLcLRangeBase_(void *p);
1633  static void destruct_GaudicLcLRangeBase_(void *p);
1634 
1635  // Function generating the singleton type initializer
1636  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::RangeBase_*)
1637  {
1638  ::Gaudi::RangeBase_ *ptr = 0;
1639  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::RangeBase_));
1640  static ::ROOT::TGenericClassInfo
1641  instance("Gaudi::RangeBase_", "GaudiKernel/Range.h", 82,
1642  typeid(::Gaudi::RangeBase_), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1643  &GaudicLcLRangeBase__Dictionary, isa_proxy, 4,
1644  sizeof(::Gaudi::RangeBase_) );
1645  instance.SetNew(&new_GaudicLcLRangeBase_);
1646  instance.SetNewArray(&newArray_GaudicLcLRangeBase_);
1647  instance.SetDelete(&delete_GaudicLcLRangeBase_);
1648  instance.SetDeleteArray(&deleteArray_GaudicLcLRangeBase_);
1649  instance.SetDestructor(&destruct_GaudicLcLRangeBase_);
1650  return &instance;
1651  }
1652  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::RangeBase_*)
1653  {
1654  return GenerateInitInstanceLocal((::Gaudi::RangeBase_*)0);
1655  }
1656  // Static variable to force the class initialization
1657  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::RangeBase_*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1658 
1659  // Dictionary for non-ClassDef classes
1660  static TClass *GaudicLcLRangeBase__Dictionary() {
1661  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::RangeBase_*)0x0)->GetClass();
1662  GaudicLcLRangeBase__TClassManip(theClass);
1663  return theClass;
1664  }
1665 
1666  static void GaudicLcLRangeBase__TClassManip(TClass* ){
1667  }
1668 
1669 } // end of namespace ROOT
1670 
1671 namespace ROOT {
1672  static TClass *Stat_Dictionary();
1673  static void Stat_TClassManip(TClass*);
1674  static void *new_Stat(void *p = 0);
1675  static void *newArray_Stat(Long_t size, void *p);
1676  static void delete_Stat(void *p);
1677  static void deleteArray_Stat(void *p);
1678  static void destruct_Stat(void *p);
1679 
1680  // Function generating the singleton type initializer
1681  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Stat*)
1682  {
1683  ::Stat *ptr = 0;
1684  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Stat));
1685  static ::ROOT::TGenericClassInfo
1686  instance("Stat", "GaudiKernel/Stat.h", 46,
1687  typeid(::Stat), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1688  &Stat_Dictionary, isa_proxy, 4,
1689  sizeof(::Stat) );
1690  instance.SetNew(&new_Stat);
1691  instance.SetNewArray(&newArray_Stat);
1692  instance.SetDelete(&delete_Stat);
1693  instance.SetDeleteArray(&deleteArray_Stat);
1694  instance.SetDestructor(&destruct_Stat);
1695  return &instance;
1696  }
1697  TGenericClassInfo *GenerateInitInstance(const ::Stat*)
1698  {
1699  return GenerateInitInstanceLocal((::Stat*)0);
1700  }
1701  // Static variable to force the class initialization
1702  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Stat*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1703 
1704  // Dictionary for non-ClassDef classes
1705  static TClass *Stat_Dictionary() {
1706  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Stat*)0x0)->GetClass();
1707  Stat_TClassManip(theClass);
1708  return theClass;
1709  }
1710 
1711  static void Stat_TClassManip(TClass* ){
1712  }
1713 
1714 } // end of namespace ROOT
1715 
1716 namespace ROOT {
1717  static TClass *AIDAcLcLIAxis_Dictionary();
1718  static void AIDAcLcLIAxis_TClassManip(TClass*);
1719  static void delete_AIDAcLcLIAxis(void *p);
1720  static void deleteArray_AIDAcLcLIAxis(void *p);
1721  static void destruct_AIDAcLcLIAxis(void *p);
1722 
1723  // Function generating the singleton type initializer
1724  static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IAxis*)
1725  {
1726  ::AIDA::IAxis *ptr = 0;
1727  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IAxis));
1728  static ::ROOT::TGenericClassInfo
1729  instance("AIDA::IAxis", "AIDA/IAxis.h", 26,
1730  typeid(::AIDA::IAxis), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1731  &AIDAcLcLIAxis_Dictionary, isa_proxy, 4,
1732  sizeof(::AIDA::IAxis) );
1733  instance.SetDelete(&delete_AIDAcLcLIAxis);
1734  instance.SetDeleteArray(&deleteArray_AIDAcLcLIAxis);
1735  instance.SetDestructor(&destruct_AIDAcLcLIAxis);
1736  return &instance;
1737  }
1738  TGenericClassInfo *GenerateInitInstance(const ::AIDA::IAxis*)
1739  {
1740  return GenerateInitInstanceLocal((::AIDA::IAxis*)0);
1741  }
1742  // Static variable to force the class initialization
1743  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IAxis*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1744 
1745  // Dictionary for non-ClassDef classes
1746  static TClass *AIDAcLcLIAxis_Dictionary() {
1747  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IAxis*)0x0)->GetClass();
1748  AIDAcLcLIAxis_TClassManip(theClass);
1749  return theClass;
1750  }
1751 
1752  static void AIDAcLcLIAxis_TClassManip(TClass* ){
1753  }
1754 
1755 } // end of namespace ROOT
1756 
1757 namespace ROOT {
1758  static TClass *AIDAcLcLIBaseHistogram_Dictionary();
1759  static void AIDAcLcLIBaseHistogram_TClassManip(TClass*);
1760  static void delete_AIDAcLcLIBaseHistogram(void *p);
1761  static void deleteArray_AIDAcLcLIBaseHistogram(void *p);
1762  static void destruct_AIDAcLcLIBaseHistogram(void *p);
1763 
1764  // Function generating the singleton type initializer
1765  static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IBaseHistogram*)
1766  {
1767  ::AIDA::IBaseHistogram *ptr = 0;
1768  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IBaseHistogram));
1769  static ::ROOT::TGenericClassInfo
1770  instance("AIDA::IBaseHistogram", "AIDA/IBaseHistogram.h", 29,
1771  typeid(::AIDA::IBaseHistogram), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1772  &AIDAcLcLIBaseHistogram_Dictionary, isa_proxy, 4,
1773  sizeof(::AIDA::IBaseHistogram) );
1774  instance.SetDelete(&delete_AIDAcLcLIBaseHistogram);
1775  instance.SetDeleteArray(&deleteArray_AIDAcLcLIBaseHistogram);
1776  instance.SetDestructor(&destruct_AIDAcLcLIBaseHistogram);
1777  return &instance;
1778  }
1779  TGenericClassInfo *GenerateInitInstance(const ::AIDA::IBaseHistogram*)
1780  {
1781  return GenerateInitInstanceLocal((::AIDA::IBaseHistogram*)0);
1782  }
1783  // Static variable to force the class initialization
1784  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IBaseHistogram*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1785 
1786  // Dictionary for non-ClassDef classes
1787  static TClass *AIDAcLcLIBaseHistogram_Dictionary() {
1788  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IBaseHistogram*)0x0)->GetClass();
1789  AIDAcLcLIBaseHistogram_TClassManip(theClass);
1790  return theClass;
1791  }
1792 
1793  static void AIDAcLcLIBaseHistogram_TClassManip(TClass* ){
1794  }
1795 
1796 } // end of namespace ROOT
1797 
1798 namespace ROOT {
1799  static TClass *AIDAcLcLIHistogram_Dictionary();
1800  static void AIDAcLcLIHistogram_TClassManip(TClass*);
1801  static void delete_AIDAcLcLIHistogram(void *p);
1802  static void deleteArray_AIDAcLcLIHistogram(void *p);
1803  static void destruct_AIDAcLcLIHistogram(void *p);
1804 
1805  // Function generating the singleton type initializer
1806  static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IHistogram*)
1807  {
1808  ::AIDA::IHistogram *ptr = 0;
1809  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IHistogram));
1810  static ::ROOT::TGenericClassInfo
1811  instance("AIDA::IHistogram", "AIDA/IHistogram.h", 26,
1812  typeid(::AIDA::IHistogram), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1813  &AIDAcLcLIHistogram_Dictionary, isa_proxy, 4,
1814  sizeof(::AIDA::IHistogram) );
1815  instance.SetDelete(&delete_AIDAcLcLIHistogram);
1816  instance.SetDeleteArray(&deleteArray_AIDAcLcLIHistogram);
1817  instance.SetDestructor(&destruct_AIDAcLcLIHistogram);
1818  return &instance;
1819  }
1820  TGenericClassInfo *GenerateInitInstance(const ::AIDA::IHistogram*)
1821  {
1822  return GenerateInitInstanceLocal((::AIDA::IHistogram*)0);
1823  }
1824  // Static variable to force the class initialization
1825  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IHistogram*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1826 
1827  // Dictionary for non-ClassDef classes
1828  static TClass *AIDAcLcLIHistogram_Dictionary() {
1829  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IHistogram*)0x0)->GetClass();
1830  AIDAcLcLIHistogram_TClassManip(theClass);
1831  return theClass;
1832  }
1833 
1834  static void AIDAcLcLIHistogram_TClassManip(TClass* ){
1835  }
1836 
1837 } // end of namespace ROOT
1838 
1839 namespace ROOT {
1840  static TClass *AIDAcLcLIHistogram1D_Dictionary();
1841  static void AIDAcLcLIHistogram1D_TClassManip(TClass*);
1842  static void delete_AIDAcLcLIHistogram1D(void *p);
1843  static void deleteArray_AIDAcLcLIHistogram1D(void *p);
1844  static void destruct_AIDAcLcLIHistogram1D(void *p);
1845 
1846  // Function generating the singleton type initializer
1847  static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IHistogram1D*)
1848  {
1849  ::AIDA::IHistogram1D *ptr = 0;
1850  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IHistogram1D));
1851  static ::ROOT::TGenericClassInfo
1852  instance("AIDA::IHistogram1D", "AIDA/IHistogram1D.h", 28,
1853  typeid(::AIDA::IHistogram1D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1854  &AIDAcLcLIHistogram1D_Dictionary, isa_proxy, 4,
1855  sizeof(::AIDA::IHistogram1D) );
1856  instance.SetDelete(&delete_AIDAcLcLIHistogram1D);
1857  instance.SetDeleteArray(&deleteArray_AIDAcLcLIHistogram1D);
1858  instance.SetDestructor(&destruct_AIDAcLcLIHistogram1D);
1859  return &instance;
1860  }
1861  TGenericClassInfo *GenerateInitInstance(const ::AIDA::IHistogram1D*)
1862  {
1863  return GenerateInitInstanceLocal((::AIDA::IHistogram1D*)0);
1864  }
1865  // Static variable to force the class initialization
1866  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IHistogram1D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1867 
1868  // Dictionary for non-ClassDef classes
1869  static TClass *AIDAcLcLIHistogram1D_Dictionary() {
1870  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IHistogram1D*)0x0)->GetClass();
1871  AIDAcLcLIHistogram1D_TClassManip(theClass);
1872  return theClass;
1873  }
1874 
1875  static void AIDAcLcLIHistogram1D_TClassManip(TClass* ){
1876  }
1877 
1878 } // end of namespace ROOT
1879 
1880 namespace ROOT {
1881  static TClass *AIDAcLcLIHistogram2D_Dictionary();
1882  static void AIDAcLcLIHistogram2D_TClassManip(TClass*);
1883  static void delete_AIDAcLcLIHistogram2D(void *p);
1884  static void deleteArray_AIDAcLcLIHistogram2D(void *p);
1885  static void destruct_AIDAcLcLIHistogram2D(void *p);
1886 
1887  // Function generating the singleton type initializer
1888  static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IHistogram2D*)
1889  {
1890  ::AIDA::IHistogram2D *ptr = 0;
1891  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IHistogram2D));
1892  static ::ROOT::TGenericClassInfo
1893  instance("AIDA::IHistogram2D", "AIDA/IHistogram2D.h", 28,
1894  typeid(::AIDA::IHistogram2D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1895  &AIDAcLcLIHistogram2D_Dictionary, isa_proxy, 4,
1896  sizeof(::AIDA::IHistogram2D) );
1897  instance.SetDelete(&delete_AIDAcLcLIHistogram2D);
1898  instance.SetDeleteArray(&deleteArray_AIDAcLcLIHistogram2D);
1899  instance.SetDestructor(&destruct_AIDAcLcLIHistogram2D);
1900  return &instance;
1901  }
1902  TGenericClassInfo *GenerateInitInstance(const ::AIDA::IHistogram2D*)
1903  {
1904  return GenerateInitInstanceLocal((::AIDA::IHistogram2D*)0);
1905  }
1906  // Static variable to force the class initialization
1907  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IHistogram2D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1908 
1909  // Dictionary for non-ClassDef classes
1910  static TClass *AIDAcLcLIHistogram2D_Dictionary() {
1911  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IHistogram2D*)0x0)->GetClass();
1912  AIDAcLcLIHistogram2D_TClassManip(theClass);
1913  return theClass;
1914  }
1915 
1916  static void AIDAcLcLIHistogram2D_TClassManip(TClass* ){
1917  }
1918 
1919 } // end of namespace ROOT
1920 
1921 namespace ROOT {
1922  static TClass *AIDAcLcLIHistogram3D_Dictionary();
1923  static void AIDAcLcLIHistogram3D_TClassManip(TClass*);
1924  static void delete_AIDAcLcLIHistogram3D(void *p);
1925  static void deleteArray_AIDAcLcLIHistogram3D(void *p);
1926  static void destruct_AIDAcLcLIHistogram3D(void *p);
1927 
1928  // Function generating the singleton type initializer
1929  static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IHistogram3D*)
1930  {
1931  ::AIDA::IHistogram3D *ptr = 0;
1932  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IHistogram3D));
1933  static ::ROOT::TGenericClassInfo
1934  instance("AIDA::IHistogram3D", "AIDA/IHistogram3D.h", 28,
1935  typeid(::AIDA::IHistogram3D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1936  &AIDAcLcLIHistogram3D_Dictionary, isa_proxy, 4,
1937  sizeof(::AIDA::IHistogram3D) );
1938  instance.SetDelete(&delete_AIDAcLcLIHistogram3D);
1939  instance.SetDeleteArray(&deleteArray_AIDAcLcLIHistogram3D);
1940  instance.SetDestructor(&destruct_AIDAcLcLIHistogram3D);
1941  return &instance;
1942  }
1943  TGenericClassInfo *GenerateInitInstance(const ::AIDA::IHistogram3D*)
1944  {
1945  return GenerateInitInstanceLocal((::AIDA::IHistogram3D*)0);
1946  }
1947  // Static variable to force the class initialization
1948  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IHistogram3D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1949 
1950  // Dictionary for non-ClassDef classes
1951  static TClass *AIDAcLcLIHistogram3D_Dictionary() {
1952  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IHistogram3D*)0x0)->GetClass();
1953  AIDAcLcLIHistogram3D_TClassManip(theClass);
1954  return theClass;
1955  }
1956 
1957  static void AIDAcLcLIHistogram3D_TClassManip(TClass* ){
1958  }
1959 
1960 } // end of namespace ROOT
1961 
1962 namespace ROOT {
1963  static TClass *AIDAcLcLIProfile_Dictionary();
1964  static void AIDAcLcLIProfile_TClassManip(TClass*);
1965  static void delete_AIDAcLcLIProfile(void *p);
1966  static void deleteArray_AIDAcLcLIProfile(void *p);
1967  static void destruct_AIDAcLcLIProfile(void *p);
1968 
1969  // Function generating the singleton type initializer
1970  static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IProfile*)
1971  {
1972  ::AIDA::IProfile *ptr = 0;
1973  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IProfile));
1974  static ::ROOT::TGenericClassInfo
1975  instance("AIDA::IProfile", "AIDA/IProfile.h", 26,
1976  typeid(::AIDA::IProfile), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1977  &AIDAcLcLIProfile_Dictionary, isa_proxy, 4,
1978  sizeof(::AIDA::IProfile) );
1979  instance.SetDelete(&delete_AIDAcLcLIProfile);
1980  instance.SetDeleteArray(&deleteArray_AIDAcLcLIProfile);
1981  instance.SetDestructor(&destruct_AIDAcLcLIProfile);
1982  return &instance;
1983  }
1984  TGenericClassInfo *GenerateInitInstance(const ::AIDA::IProfile*)
1985  {
1986  return GenerateInitInstanceLocal((::AIDA::IProfile*)0);
1987  }
1988  // Static variable to force the class initialization
1989  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IProfile*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1990 
1991  // Dictionary for non-ClassDef classes
1992  static TClass *AIDAcLcLIProfile_Dictionary() {
1993  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IProfile*)0x0)->GetClass();
1994  AIDAcLcLIProfile_TClassManip(theClass);
1995  return theClass;
1996  }
1997 
1998  static void AIDAcLcLIProfile_TClassManip(TClass* ){
1999  }
2000 
2001 } // end of namespace ROOT
2002 
2003 namespace ROOT {
2004  static TClass *AIDAcLcLIProfile1D_Dictionary();
2005  static void AIDAcLcLIProfile1D_TClassManip(TClass*);
2006  static void delete_AIDAcLcLIProfile1D(void *p);
2007  static void deleteArray_AIDAcLcLIProfile1D(void *p);
2008  static void destruct_AIDAcLcLIProfile1D(void *p);
2009 
2010  // Function generating the singleton type initializer
2011  static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IProfile1D*)
2012  {
2013  ::AIDA::IProfile1D *ptr = 0;
2014  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IProfile1D));
2015  static ::ROOT::TGenericClassInfo
2016  instance("AIDA::IProfile1D", "AIDA/IProfile1D.h", 28,
2017  typeid(::AIDA::IProfile1D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2018  &AIDAcLcLIProfile1D_Dictionary, isa_proxy, 4,
2019  sizeof(::AIDA::IProfile1D) );
2020  instance.SetDelete(&delete_AIDAcLcLIProfile1D);
2021  instance.SetDeleteArray(&deleteArray_AIDAcLcLIProfile1D);
2022  instance.SetDestructor(&destruct_AIDAcLcLIProfile1D);
2023  return &instance;
2024  }
2025  TGenericClassInfo *GenerateInitInstance(const ::AIDA::IProfile1D*)
2026  {
2027  return GenerateInitInstanceLocal((::AIDA::IProfile1D*)0);
2028  }
2029  // Static variable to force the class initialization
2030  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IProfile1D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2031 
2032  // Dictionary for non-ClassDef classes
2033  static TClass *AIDAcLcLIProfile1D_Dictionary() {
2034  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IProfile1D*)0x0)->GetClass();
2035  AIDAcLcLIProfile1D_TClassManip(theClass);
2036  return theClass;
2037  }
2038 
2039  static void AIDAcLcLIProfile1D_TClassManip(TClass* ){
2040  }
2041 
2042 } // end of namespace ROOT
2043 
2044 namespace ROOT {
2045  static TClass *AIDAcLcLIProfile2D_Dictionary();
2046  static void AIDAcLcLIProfile2D_TClassManip(TClass*);
2047  static void delete_AIDAcLcLIProfile2D(void *p);
2048  static void deleteArray_AIDAcLcLIProfile2D(void *p);
2049  static void destruct_AIDAcLcLIProfile2D(void *p);
2050 
2051  // Function generating the singleton type initializer
2052  static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IProfile2D*)
2053  {
2054  ::AIDA::IProfile2D *ptr = 0;
2055  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IProfile2D));
2056  static ::ROOT::TGenericClassInfo
2057  instance("AIDA::IProfile2D", "AIDA/IProfile2D.h", 28,
2058  typeid(::AIDA::IProfile2D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2059  &AIDAcLcLIProfile2D_Dictionary, isa_proxy, 4,
2060  sizeof(::AIDA::IProfile2D) );
2061  instance.SetDelete(&delete_AIDAcLcLIProfile2D);
2062  instance.SetDeleteArray(&deleteArray_AIDAcLcLIProfile2D);
2063  instance.SetDestructor(&destruct_AIDAcLcLIProfile2D);
2064  return &instance;
2065  }
2066  TGenericClassInfo *GenerateInitInstance(const ::AIDA::IProfile2D*)
2067  {
2068  return GenerateInitInstanceLocal((::AIDA::IProfile2D*)0);
2069  }
2070  // Static variable to force the class initialization
2071  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IProfile2D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2072 
2073  // Dictionary for non-ClassDef classes
2074  static TClass *AIDAcLcLIProfile2D_Dictionary() {
2075  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IProfile2D*)0x0)->GetClass();
2076  AIDAcLcLIProfile2D_TClassManip(theClass);
2077  return theClass;
2078  }
2079 
2080  static void AIDAcLcLIProfile2D_TClassManip(TClass* ){
2081  }
2082 
2083 } // end of namespace ROOT
2084 
2085 namespace ROOT {
2086  static TClass *GaudiPythoncLcLHelper_Dictionary();
2087  static void GaudiPythoncLcLHelper_TClassManip(TClass*);
2088  static void *new_GaudiPythoncLcLHelper(void *p = 0);
2089  static void *newArray_GaudiPythoncLcLHelper(Long_t size, void *p);
2090  static void delete_GaudiPythoncLcLHelper(void *p);
2091  static void deleteArray_GaudiPythoncLcLHelper(void *p);
2092  static void destruct_GaudiPythoncLcLHelper(void *p);
2093 
2094  // Function generating the singleton type initializer
2095  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::Helper*)
2096  {
2097  ::GaudiPython::Helper *ptr = 0;
2098  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::Helper));
2099  static ::ROOT::TGenericClassInfo
2100  instance("GaudiPython::Helper", "GaudiPython/Helpers.h", 54,
2101  typeid(::GaudiPython::Helper), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2102  &GaudiPythoncLcLHelper_Dictionary, isa_proxy, 4,
2103  sizeof(::GaudiPython::Helper) );
2104  instance.SetNew(&new_GaudiPythoncLcLHelper);
2105  instance.SetNewArray(&newArray_GaudiPythoncLcLHelper);
2106  instance.SetDelete(&delete_GaudiPythoncLcLHelper);
2107  instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLHelper);
2108  instance.SetDestructor(&destruct_GaudiPythoncLcLHelper);
2109  return &instance;
2110  }
2111  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::Helper*)
2112  {
2113  return GenerateInitInstanceLocal((::GaudiPython::Helper*)0);
2114  }
2115  // Static variable to force the class initialization
2116  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::Helper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2117 
2118  // Dictionary for non-ClassDef classes
2119  static TClass *GaudiPythoncLcLHelper_Dictionary() {
2120  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::Helper*)0x0)->GetClass();
2121  GaudiPythoncLcLHelper_TClassManip(theClass);
2122  return theClass;
2123  }
2124 
2125  static void GaudiPythoncLcLHelper_TClassManip(TClass* ){
2126  }
2127 
2128 } // end of namespace ROOT
2129 
2130 namespace ROOT {
2131  static TClass *GaudiCommonlEAlgorithmgR_Dictionary();
2132  static void GaudiCommonlEAlgorithmgR_TClassManip(TClass*);
2133 
2134  // Function generating the singleton type initializer
2135  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiCommon<Algorithm>*)
2136  {
2137  ::GaudiCommon<Algorithm> *ptr = 0;
2138  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiCommon<Algorithm>));
2139  static ::ROOT::TGenericClassInfo
2140  instance("GaudiCommon<Algorithm>", "GaudiAlg/GaudiCommon.h", 80,
2141  typeid(::GaudiCommon<Algorithm>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2142  &GaudiCommonlEAlgorithmgR_Dictionary, isa_proxy, 4,
2143  sizeof(::GaudiCommon<Algorithm>) );
2144  return &instance;
2145  }
2146  TGenericClassInfo *GenerateInitInstance(const ::GaudiCommon<Algorithm>*)
2147  {
2148  return GenerateInitInstanceLocal((::GaudiCommon<Algorithm>*)0);
2149  }
2150  // Static variable to force the class initialization
2151  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiCommon<Algorithm>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2152 
2153  // Dictionary for non-ClassDef classes
2154  static TClass *GaudiCommonlEAlgorithmgR_Dictionary() {
2155  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiCommon<Algorithm>*)0x0)->GetClass();
2156  GaudiCommonlEAlgorithmgR_TClassManip(theClass);
2157  return theClass;
2158  }
2159 
2160  static void GaudiCommonlEAlgorithmgR_TClassManip(TClass* ){
2161  }
2162 
2163 } // end of namespace ROOT
2164 
2165 namespace ROOT {
2166  static TClass *GaudiCommonlEAlgToolgR_Dictionary();
2167  static void GaudiCommonlEAlgToolgR_TClassManip(TClass*);
2168 
2169  // Function generating the singleton type initializer
2170  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiCommon<AlgTool>*)
2171  {
2172  ::GaudiCommon<AlgTool> *ptr = 0;
2173  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiCommon<AlgTool>));
2174  static ::ROOT::TGenericClassInfo
2175  instance("GaudiCommon<AlgTool>", "GaudiAlg/GaudiCommon.h", 80,
2176  typeid(::GaudiCommon<AlgTool>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2177  &GaudiCommonlEAlgToolgR_Dictionary, isa_proxy, 4,
2178  sizeof(::GaudiCommon<AlgTool>) );
2179  return &instance;
2180  }
2181  TGenericClassInfo *GenerateInitInstance(const ::GaudiCommon<AlgTool>*)
2182  {
2183  return GenerateInitInstanceLocal((::GaudiCommon<AlgTool>*)0);
2184  }
2185  // Static variable to force the class initialization
2186  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiCommon<AlgTool>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2187 
2188  // Dictionary for non-ClassDef classes
2189  static TClass *GaudiCommonlEAlgToolgR_Dictionary() {
2190  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiCommon<AlgTool>*)0x0)->GetClass();
2191  GaudiCommonlEAlgToolgR_TClassManip(theClass);
2192  return theClass;
2193  }
2194 
2195  static void GaudiCommonlEAlgToolgR_TClassManip(TClass* ){
2196  }
2197 
2198 } // end of namespace ROOT
2199 
2200 namespace ROOT {
2201  static TClass *GaudiAlgorithm_Dictionary();
2202  static void GaudiAlgorithm_TClassManip(TClass*);
2203  static void delete_GaudiAlgorithm(void *p);
2204  static void deleteArray_GaudiAlgorithm(void *p);
2205  static void destruct_GaudiAlgorithm(void *p);
2206 
2207  // Function generating the singleton type initializer
2208  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlgorithm*)
2209  {
2210  ::GaudiAlgorithm *ptr = 0;
2211  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlgorithm));
2212  static ::ROOT::TGenericClassInfo
2213  instance("GaudiAlgorithm", "GaudiAlg/GaudiAlgorithm.h", 94,
2214  typeid(::GaudiAlgorithm), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2215  &GaudiAlgorithm_Dictionary, isa_proxy, 4,
2216  sizeof(::GaudiAlgorithm) );
2217  instance.SetDelete(&delete_GaudiAlgorithm);
2218  instance.SetDeleteArray(&deleteArray_GaudiAlgorithm);
2219  instance.SetDestructor(&destruct_GaudiAlgorithm);
2220  return &instance;
2221  }
2222  TGenericClassInfo *GenerateInitInstance(const ::GaudiAlgorithm*)
2223  {
2224  return GenerateInitInstanceLocal((::GaudiAlgorithm*)0);
2225  }
2226  // Static variable to force the class initialization
2227  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlgorithm*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2228 
2229  // Dictionary for non-ClassDef classes
2230  static TClass *GaudiAlgorithm_Dictionary() {
2231  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlgorithm*)0x0)->GetClass();
2232  GaudiAlgorithm_TClassManip(theClass);
2233  return theClass;
2234  }
2235 
2236  static void GaudiAlgorithm_TClassManip(TClass* ){
2237  }
2238 
2239 } // end of namespace ROOT
2240 
2241 namespace ROOT {
2242  static TClass *GaudiPythoncLcLAlgDecorator_Dictionary();
2243  static void GaudiPythoncLcLAlgDecorator_TClassManip(TClass*);
2244  static void *new_GaudiPythoncLcLAlgDecorator(void *p = 0);
2245  static void *newArray_GaudiPythoncLcLAlgDecorator(Long_t size, void *p);
2246  static void delete_GaudiPythoncLcLAlgDecorator(void *p);
2247  static void deleteArray_GaudiPythoncLcLAlgDecorator(void *p);
2248  static void destruct_GaudiPythoncLcLAlgDecorator(void *p);
2249 
2250  // Function generating the singleton type initializer
2251  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::AlgDecorator*)
2252  {
2253  ::GaudiPython::AlgDecorator *ptr = 0;
2254  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::AlgDecorator));
2255  static ::ROOT::TGenericClassInfo
2256  instance("GaudiPython::AlgDecorator", "GaudiPython/AlgDecorators.h", 46,
2257  typeid(::GaudiPython::AlgDecorator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2258  &GaudiPythoncLcLAlgDecorator_Dictionary, isa_proxy, 4,
2259  sizeof(::GaudiPython::AlgDecorator) );
2260  instance.SetNew(&new_GaudiPythoncLcLAlgDecorator);
2261  instance.SetNewArray(&newArray_GaudiPythoncLcLAlgDecorator);
2262  instance.SetDelete(&delete_GaudiPythoncLcLAlgDecorator);
2263  instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLAlgDecorator);
2264  instance.SetDestructor(&destruct_GaudiPythoncLcLAlgDecorator);
2265  return &instance;
2266  }
2267  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::AlgDecorator*)
2268  {
2269  return GenerateInitInstanceLocal((::GaudiPython::AlgDecorator*)0);
2270  }
2271  // Static variable to force the class initialization
2272  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::AlgDecorator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2273 
2274  // Dictionary for non-ClassDef classes
2275  static TClass *GaudiPythoncLcLAlgDecorator_Dictionary() {
2276  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::AlgDecorator*)0x0)->GetClass();
2277  GaudiPythoncLcLAlgDecorator_TClassManip(theClass);
2278  return theClass;
2279  }
2280 
2281  static void GaudiPythoncLcLAlgDecorator_TClassManip(TClass* ){
2282  }
2283 
2284 } // end of namespace ROOT
2285 
2286 namespace ROOT {
2287  static TClass *GaudiPythoncLcLPyAlgorithm_Dictionary();
2288  static void GaudiPythoncLcLPyAlgorithm_TClassManip(TClass*);
2289  static void delete_GaudiPythoncLcLPyAlgorithm(void *p);
2290  static void deleteArray_GaudiPythoncLcLPyAlgorithm(void *p);
2291  static void destruct_GaudiPythoncLcLPyAlgorithm(void *p);
2292 
2293  // Function generating the singleton type initializer
2294  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::PyAlgorithm*)
2295  {
2296  ::GaudiPython::PyAlgorithm *ptr = 0;
2297  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::PyAlgorithm));
2298  static ::ROOT::TGenericClassInfo
2299  instance("GaudiPython::PyAlgorithm", "GaudiPython/Algorithm.h", 32,
2300  typeid(::GaudiPython::PyAlgorithm), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2301  &GaudiPythoncLcLPyAlgorithm_Dictionary, isa_proxy, 4,
2302  sizeof(::GaudiPython::PyAlgorithm) );
2303  instance.SetDelete(&delete_GaudiPythoncLcLPyAlgorithm);
2304  instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLPyAlgorithm);
2305  instance.SetDestructor(&destruct_GaudiPythoncLcLPyAlgorithm);
2306  return &instance;
2307  }
2308  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::PyAlgorithm*)
2309  {
2310  return GenerateInitInstanceLocal((::GaudiPython::PyAlgorithm*)0);
2311  }
2312  // Static variable to force the class initialization
2313  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::PyAlgorithm*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2314 
2315  // Dictionary for non-ClassDef classes
2316  static TClass *GaudiPythoncLcLPyAlgorithm_Dictionary() {
2317  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::PyAlgorithm*)0x0)->GetClass();
2318  GaudiPythoncLcLPyAlgorithm_TClassManip(theClass);
2319  return theClass;
2320  }
2321 
2322  static void GaudiPythoncLcLPyAlgorithm_TClassManip(TClass* ){
2323  }
2324 
2325 } // end of namespace ROOT
2326 
2327 namespace ROOT {
2328  static TClass *GaudiPythoncLcLPyAlglEGaudiAlgorithmgR_Dictionary();
2329  static void GaudiPythoncLcLPyAlglEGaudiAlgorithmgR_TClassManip(TClass*);
2330 
2331  // Function generating the singleton type initializer
2332  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::PyAlg<GaudiAlgorithm>*)
2333  {
2334  ::GaudiPython::PyAlg<GaudiAlgorithm> *ptr = 0;
2335  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::PyAlg<GaudiAlgorithm>));
2336  static ::ROOT::TGenericClassInfo
2337  instance("GaudiPython::PyAlg<GaudiAlgorithm>", "GaudiPython/Algorithm.h", 62,
2338  typeid(::GaudiPython::PyAlg<GaudiAlgorithm>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2339  &GaudiPythoncLcLPyAlglEGaudiAlgorithmgR_Dictionary, isa_proxy, 4,
2340  sizeof(::GaudiPython::PyAlg<GaudiAlgorithm>) );
2341  return &instance;
2342  }
2343  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::PyAlg<GaudiAlgorithm>*)
2344  {
2345  return GenerateInitInstanceLocal((::GaudiPython::PyAlg<GaudiAlgorithm>*)0);
2346  }
2347  // Static variable to force the class initialization
2348  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::PyAlg<GaudiAlgorithm>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2349 
2350  // Dictionary for non-ClassDef classes
2351  static TClass *GaudiPythoncLcLPyAlglEGaudiAlgorithmgR_Dictionary() {
2352  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::PyAlg<GaudiAlgorithm>*)0x0)->GetClass();
2353  GaudiPythoncLcLPyAlglEGaudiAlgorithmgR_TClassManip(theClass);
2354  return theClass;
2355  }
2356 
2357  static void GaudiPythoncLcLPyAlglEGaudiAlgorithmgR_TClassManip(TClass* ){
2358  }
2359 
2360 } // end of namespace ROOT
2361 
2362 namespace ROOT {
2363  static TClass *GaudiPythoncLcLPyAlglEGaudiHistoAlggR_Dictionary();
2364  static void GaudiPythoncLcLPyAlglEGaudiHistoAlggR_TClassManip(TClass*);
2365 
2366  // Function generating the singleton type initializer
2367  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::PyAlg<GaudiHistoAlg>*)
2368  {
2369  ::GaudiPython::PyAlg<GaudiHistoAlg> *ptr = 0;
2370  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::PyAlg<GaudiHistoAlg>));
2371  static ::ROOT::TGenericClassInfo
2372  instance("GaudiPython::PyAlg<GaudiHistoAlg>", "GaudiPython/Algorithm.h", 62,
2373  typeid(::GaudiPython::PyAlg<GaudiHistoAlg>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2374  &GaudiPythoncLcLPyAlglEGaudiHistoAlggR_Dictionary, isa_proxy, 4,
2375  sizeof(::GaudiPython::PyAlg<GaudiHistoAlg>) );
2376  return &instance;
2377  }
2378  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::PyAlg<GaudiHistoAlg>*)
2379  {
2380  return GenerateInitInstanceLocal((::GaudiPython::PyAlg<GaudiHistoAlg>*)0);
2381  }
2382  // Static variable to force the class initialization
2383  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::PyAlg<GaudiHistoAlg>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2384 
2385  // Dictionary for non-ClassDef classes
2386  static TClass *GaudiPythoncLcLPyAlglEGaudiHistoAlggR_Dictionary() {
2387  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::PyAlg<GaudiHistoAlg>*)0x0)->GetClass();
2388  GaudiPythoncLcLPyAlglEGaudiHistoAlggR_TClassManip(theClass);
2389  return theClass;
2390  }
2391 
2392  static void GaudiPythoncLcLPyAlglEGaudiHistoAlggR_TClassManip(TClass* ){
2393  }
2394 
2395 } // end of namespace ROOT
2396 
2397 namespace ROOT {
2398  static TClass *GaudiPythoncLcLPyAlglEGaudiTupleAlggR_Dictionary();
2399  static void GaudiPythoncLcLPyAlglEGaudiTupleAlggR_TClassManip(TClass*);
2400 
2401  // Function generating the singleton type initializer
2402  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::PyAlg<GaudiTupleAlg>*)
2403  {
2404  ::GaudiPython::PyAlg<GaudiTupleAlg> *ptr = 0;
2405  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::PyAlg<GaudiTupleAlg>));
2406  static ::ROOT::TGenericClassInfo
2407  instance("GaudiPython::PyAlg<GaudiTupleAlg>", "GaudiPython/Algorithm.h", 62,
2408  typeid(::GaudiPython::PyAlg<GaudiTupleAlg>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2409  &GaudiPythoncLcLPyAlglEGaudiTupleAlggR_Dictionary, isa_proxy, 4,
2410  sizeof(::GaudiPython::PyAlg<GaudiTupleAlg>) );
2411  return &instance;
2412  }
2413  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::PyAlg<GaudiTupleAlg>*)
2414  {
2415  return GenerateInitInstanceLocal((::GaudiPython::PyAlg<GaudiTupleAlg>*)0);
2416  }
2417  // Static variable to force the class initialization
2418  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::PyAlg<GaudiTupleAlg>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2419 
2420  // Dictionary for non-ClassDef classes
2421  static TClass *GaudiPythoncLcLPyAlglEGaudiTupleAlggR_Dictionary() {
2422  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::PyAlg<GaudiTupleAlg>*)0x0)->GetClass();
2423  GaudiPythoncLcLPyAlglEGaudiTupleAlggR_TClassManip(theClass);
2424  return theClass;
2425  }
2426 
2427  static void GaudiPythoncLcLPyAlglEGaudiTupleAlggR_TClassManip(TClass* ){
2428  }
2429 
2430 } // end of namespace ROOT
2431 
2432 namespace ROOT {
2433  static TClass *GaudiPythoncLcLCallbackStreamBuf_Dictionary();
2434  static void GaudiPythoncLcLCallbackStreamBuf_TClassManip(TClass*);
2435  static void delete_GaudiPythoncLcLCallbackStreamBuf(void *p);
2436  static void deleteArray_GaudiPythoncLcLCallbackStreamBuf(void *p);
2437  static void destruct_GaudiPythoncLcLCallbackStreamBuf(void *p);
2438 
2439  // Function generating the singleton type initializer
2440  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::CallbackStreamBuf*)
2441  {
2442  ::GaudiPython::CallbackStreamBuf *ptr = 0;
2443  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::CallbackStreamBuf));
2444  static ::ROOT::TGenericClassInfo
2445  instance("GaudiPython::CallbackStreamBuf", "GaudiPython/CallbackStreamBuf.h", 17,
2446  typeid(::GaudiPython::CallbackStreamBuf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2447  &GaudiPythoncLcLCallbackStreamBuf_Dictionary, isa_proxy, 4,
2448  sizeof(::GaudiPython::CallbackStreamBuf) );
2449  instance.SetDelete(&delete_GaudiPythoncLcLCallbackStreamBuf);
2450  instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLCallbackStreamBuf);
2451  instance.SetDestructor(&destruct_GaudiPythoncLcLCallbackStreamBuf);
2452  return &instance;
2453  }
2454  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::CallbackStreamBuf*)
2455  {
2456  return GenerateInitInstanceLocal((::GaudiPython::CallbackStreamBuf*)0);
2457  }
2458  // Static variable to force the class initialization
2459  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::CallbackStreamBuf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2460 
2461  // Dictionary for non-ClassDef classes
2462  static TClass *GaudiPythoncLcLCallbackStreamBuf_Dictionary() {
2463  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::CallbackStreamBuf*)0x0)->GetClass();
2464  GaudiPythoncLcLCallbackStreamBuf_TClassManip(theClass);
2465  return theClass;
2466  }
2467 
2468  static void GaudiPythoncLcLCallbackStreamBuf_TClassManip(TClass* ){
2469  }
2470 
2471 } // end of namespace ROOT
2472 
2473 namespace ROOT {
2474  static TClass *GaudicLcLUtilscLcLHistoscLcLTable_Dictionary();
2475  static void GaudicLcLUtilscLcLHistoscLcLTable_TClassManip(TClass*);
2476  static void *new_GaudicLcLUtilscLcLHistoscLcLTable(void *p = 0);
2477  static void *newArray_GaudicLcLUtilscLcLHistoscLcLTable(Long_t size, void *p);
2478  static void delete_GaudicLcLUtilscLcLHistoscLcLTable(void *p);
2479  static void deleteArray_GaudicLcLUtilscLcLHistoscLcLTable(void *p);
2480  static void destruct_GaudicLcLUtilscLcLHistoscLcLTable(void *p);
2481 
2482  // Function generating the singleton type initializer
2483  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Utils::Histos::Table*)
2484  {
2485  ::Gaudi::Utils::Histos::Table *ptr = 0;
2486  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Utils::Histos::Table));
2487  static ::ROOT::TGenericClassInfo
2488  instance("Gaudi::Utils::Histos::Table", "GaudiUtils/HistoTableFormat.h", 381,
2489  typeid(::Gaudi::Utils::Histos::Table), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2490  &GaudicLcLUtilscLcLHistoscLcLTable_Dictionary, isa_proxy, 4,
2491  sizeof(::Gaudi::Utils::Histos::Table) );
2492  instance.SetNew(&new_GaudicLcLUtilscLcLHistoscLcLTable);
2493  instance.SetNewArray(&newArray_GaudicLcLUtilscLcLHistoscLcLTable);
2494  instance.SetDelete(&delete_GaudicLcLUtilscLcLHistoscLcLTable);
2495  instance.SetDeleteArray(&deleteArray_GaudicLcLUtilscLcLHistoscLcLTable);
2496  instance.SetDestructor(&destruct_GaudicLcLUtilscLcLHistoscLcLTable);
2497  return &instance;
2498  }
2499  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Utils::Histos::Table*)
2500  {
2501  return GenerateInitInstanceLocal((::Gaudi::Utils::Histos::Table*)0);
2502  }
2503  // Static variable to force the class initialization
2504  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Utils::Histos::Table*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2505 
2506  // Dictionary for non-ClassDef classes
2507  static TClass *GaudicLcLUtilscLcLHistoscLcLTable_Dictionary() {
2508  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Utils::Histos::Table*)0x0)->GetClass();
2509  GaudicLcLUtilscLcLHistoscLcLTable_TClassManip(theClass);
2510  return theClass;
2511  }
2512 
2513  static void GaudicLcLUtilscLcLHistoscLcLTable_TClassManip(TClass* ){
2514  }
2515 
2516 } // end of namespace ROOT
2517 
2518 namespace ROOT {
2519  static TClass *GaudiAlgcLcLID_Dictionary();
2520  static void GaudiAlgcLcLID_TClassManip(TClass*);
2521  static void *new_GaudiAlgcLcLID(void *p = 0);
2522  static void *newArray_GaudiAlgcLcLID(Long_t size, void *p);
2523  static void delete_GaudiAlgcLcLID(void *p);
2524  static void deleteArray_GaudiAlgcLcLID(void *p);
2525  static void destruct_GaudiAlgcLcLID(void *p);
2526 
2527  // Function generating the singleton type initializer
2528  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::ID*)
2529  {
2530  ::GaudiAlg::ID *ptr = 0;
2531  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::ID));
2532  static ::ROOT::TGenericClassInfo
2533  instance("GaudiAlg::ID", "GaudiAlg/GaudiHistoID.h", 44,
2534  typeid(::GaudiAlg::ID), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2535  &GaudiAlgcLcLID_Dictionary, isa_proxy, 4,
2536  sizeof(::GaudiAlg::ID) );
2537  instance.SetNew(&new_GaudiAlgcLcLID);
2538  instance.SetNewArray(&newArray_GaudiAlgcLcLID);
2539  instance.SetDelete(&delete_GaudiAlgcLcLID);
2540  instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLID);
2541  instance.SetDestructor(&destruct_GaudiAlgcLcLID);
2542  return &instance;
2543  }
2544  TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::ID*)
2545  {
2546  return GenerateInitInstanceLocal((::GaudiAlg::ID*)0);
2547  }
2548  // Static variable to force the class initialization
2549  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::ID*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2550 
2551  // Dictionary for non-ClassDef classes
2552  static TClass *GaudiAlgcLcLID_Dictionary() {
2553  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::ID*)0x0)->GetClass();
2554  GaudiAlgcLcLID_TClassManip(theClass);
2555  return theClass;
2556  }
2557 
2558  static void GaudiAlgcLcLID_TClassManip(TClass* ){
2559  }
2560 
2561 } // end of namespace ROOT
2562 
2563 namespace ROOT {
2564  static TClass *GaudiHistoslEGaudiAlgorithmgR_Dictionary();
2565  static void GaudiHistoslEGaudiAlgorithmgR_TClassManip(TClass*);
2566  static void delete_GaudiHistoslEGaudiAlgorithmgR(void *p);
2567  static void deleteArray_GaudiHistoslEGaudiAlgorithmgR(void *p);
2568  static void destruct_GaudiHistoslEGaudiAlgorithmgR(void *p);
2569 
2570  // Function generating the singleton type initializer
2571  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHistos<GaudiAlgorithm>*)
2572  {
2573  ::GaudiHistos<GaudiAlgorithm> *ptr = 0;
2574  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHistos<GaudiAlgorithm>));
2575  static ::ROOT::TGenericClassInfo
2576  instance("GaudiHistos<GaudiAlgorithm>", "GaudiAlg/GaudiHistos.h", 56,
2577  typeid(::GaudiHistos<GaudiAlgorithm>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2578  &GaudiHistoslEGaudiAlgorithmgR_Dictionary, isa_proxy, 4,
2579  sizeof(::GaudiHistos<GaudiAlgorithm>) );
2580  instance.SetDelete(&delete_GaudiHistoslEGaudiAlgorithmgR);
2581  instance.SetDeleteArray(&deleteArray_GaudiHistoslEGaudiAlgorithmgR);
2582  instance.SetDestructor(&destruct_GaudiHistoslEGaudiAlgorithmgR);
2583  return &instance;
2584  }
2585  TGenericClassInfo *GenerateInitInstance(const ::GaudiHistos<GaudiAlgorithm>*)
2586  {
2587  return GenerateInitInstanceLocal((::GaudiHistos<GaudiAlgorithm>*)0);
2588  }
2589  // Static variable to force the class initialization
2590  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHistos<GaudiAlgorithm>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2591 
2592  // Dictionary for non-ClassDef classes
2593  static TClass *GaudiHistoslEGaudiAlgorithmgR_Dictionary() {
2594  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHistos<GaudiAlgorithm>*)0x0)->GetClass();
2595  GaudiHistoslEGaudiAlgorithmgR_TClassManip(theClass);
2596  return theClass;
2597  }
2598 
2599  static void GaudiHistoslEGaudiAlgorithmgR_TClassManip(TClass* ){
2600  }
2601 
2602 } // end of namespace ROOT
2603 
2604 namespace ROOT {
2605  static TClass *GaudiHistoslEGaudiToolgR_Dictionary();
2606  static void GaudiHistoslEGaudiToolgR_TClassManip(TClass*);
2607  static void delete_GaudiHistoslEGaudiToolgR(void *p);
2608  static void deleteArray_GaudiHistoslEGaudiToolgR(void *p);
2609  static void destruct_GaudiHistoslEGaudiToolgR(void *p);
2610 
2611  // Function generating the singleton type initializer
2612  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHistos<GaudiTool>*)
2613  {
2614  ::GaudiHistos<GaudiTool> *ptr = 0;
2615  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHistos<GaudiTool>));
2616  static ::ROOT::TGenericClassInfo
2617  instance("GaudiHistos<GaudiTool>", "GaudiAlg/GaudiHistos.h", 56,
2618  typeid(::GaudiHistos<GaudiTool>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2619  &GaudiHistoslEGaudiToolgR_Dictionary, isa_proxy, 4,
2620  sizeof(::GaudiHistos<GaudiTool>) );
2621  instance.SetDelete(&delete_GaudiHistoslEGaudiToolgR);
2622  instance.SetDeleteArray(&deleteArray_GaudiHistoslEGaudiToolgR);
2623  instance.SetDestructor(&destruct_GaudiHistoslEGaudiToolgR);
2624  return &instance;
2625  }
2626  TGenericClassInfo *GenerateInitInstance(const ::GaudiHistos<GaudiTool>*)
2627  {
2628  return GenerateInitInstanceLocal((::GaudiHistos<GaudiTool>*)0);
2629  }
2630  // Static variable to force the class initialization
2631  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHistos<GaudiTool>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2632 
2633  // Dictionary for non-ClassDef classes
2634  static TClass *GaudiHistoslEGaudiToolgR_Dictionary() {
2635  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHistos<GaudiTool>*)0x0)->GetClass();
2636  GaudiHistoslEGaudiToolgR_TClassManip(theClass);
2637  return theClass;
2638  }
2639 
2640  static void GaudiHistoslEGaudiToolgR_TClassManip(TClass* ){
2641  }
2642 
2643 } // end of namespace ROOT
2644 
2645 namespace ROOT {
2646  static TClass *GaudiPythoncLcLHistoDecorator_Dictionary();
2647  static void GaudiPythoncLcLHistoDecorator_TClassManip(TClass*);
2648  static void *new_GaudiPythoncLcLHistoDecorator(void *p = 0);
2649  static void *newArray_GaudiPythoncLcLHistoDecorator(Long_t size, void *p);
2650  static void delete_GaudiPythoncLcLHistoDecorator(void *p);
2651  static void deleteArray_GaudiPythoncLcLHistoDecorator(void *p);
2652  static void destruct_GaudiPythoncLcLHistoDecorator(void *p);
2653 
2654  // Function generating the singleton type initializer
2655  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::HistoDecorator*)
2656  {
2657  ::GaudiPython::HistoDecorator *ptr = 0;
2658  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::HistoDecorator));
2659  static ::ROOT::TGenericClassInfo
2660  instance("GaudiPython::HistoDecorator", "GaudiPython/HistoDecorator.h", 26,
2661  typeid(::GaudiPython::HistoDecorator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2662  &GaudiPythoncLcLHistoDecorator_Dictionary, isa_proxy, 4,
2663  sizeof(::GaudiPython::HistoDecorator) );
2664  instance.SetNew(&new_GaudiPythoncLcLHistoDecorator);
2665  instance.SetNewArray(&newArray_GaudiPythoncLcLHistoDecorator);
2666  instance.SetDelete(&delete_GaudiPythoncLcLHistoDecorator);
2667  instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLHistoDecorator);
2668  instance.SetDestructor(&destruct_GaudiPythoncLcLHistoDecorator);
2669  return &instance;
2670  }
2671  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::HistoDecorator*)
2672  {
2673  return GenerateInitInstanceLocal((::GaudiPython::HistoDecorator*)0);
2674  }
2675  // Static variable to force the class initialization
2676  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::HistoDecorator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2677 
2678  // Dictionary for non-ClassDef classes
2679  static TClass *GaudiPythoncLcLHistoDecorator_Dictionary() {
2680  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::HistoDecorator*)0x0)->GetClass();
2681  GaudiPythoncLcLHistoDecorator_TClassManip(theClass);
2682  return theClass;
2683  }
2684 
2685  static void GaudiPythoncLcLHistoDecorator_TClassManip(TClass* ){
2686  }
2687 
2688 } // end of namespace ROOT
2689 
2690 namespace ROOT {
2691  static TClass *GaudiPythoncLcLPrinterlEContainedObjectgR_Dictionary();
2692  static void GaudiPythoncLcLPrinterlEContainedObjectgR_TClassManip(TClass*);
2693  static void *new_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p = 0);
2694  static void *newArray_GaudiPythoncLcLPrinterlEContainedObjectgR(Long_t size, void *p);
2695  static void delete_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p);
2696  static void deleteArray_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p);
2697  static void destruct_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p);
2698 
2699  // Function generating the singleton type initializer
2700  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::Printer<ContainedObject>*)
2701  {
2702  ::GaudiPython::Printer<ContainedObject> *ptr = 0;
2703  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::Printer<ContainedObject>));
2704  static ::ROOT::TGenericClassInfo
2705  instance("GaudiPython::Printer<ContainedObject>", "GaudiPython/Printer.h", 35,
2706  typeid(::GaudiPython::Printer<ContainedObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2707  &GaudiPythoncLcLPrinterlEContainedObjectgR_Dictionary, isa_proxy, 4,
2708  sizeof(::GaudiPython::Printer<ContainedObject>) );
2709  instance.SetNew(&new_GaudiPythoncLcLPrinterlEContainedObjectgR);
2710  instance.SetNewArray(&newArray_GaudiPythoncLcLPrinterlEContainedObjectgR);
2711  instance.SetDelete(&delete_GaudiPythoncLcLPrinterlEContainedObjectgR);
2712  instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLPrinterlEContainedObjectgR);
2713  instance.SetDestructor(&destruct_GaudiPythoncLcLPrinterlEContainedObjectgR);
2714  return &instance;
2715  }
2716  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::Printer<ContainedObject>*)
2717  {
2718  return GenerateInitInstanceLocal((::GaudiPython::Printer<ContainedObject>*)0);
2719  }
2720  // Static variable to force the class initialization
2721  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::Printer<ContainedObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2722 
2723  // Dictionary for non-ClassDef classes
2724  static TClass *GaudiPythoncLcLPrinterlEContainedObjectgR_Dictionary() {
2725  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::Printer<ContainedObject>*)0x0)->GetClass();
2726  GaudiPythoncLcLPrinterlEContainedObjectgR_TClassManip(theClass);
2727  return theClass;
2728  }
2729 
2730  static void GaudiPythoncLcLPrinterlEContainedObjectgR_TClassManip(TClass* ){
2731  }
2732 
2733 } // end of namespace ROOT
2734 
2735 namespace ROOT {
2736  static TClass *GaudiPythoncLcLPrinterlEDataObjectgR_Dictionary();
2737  static void GaudiPythoncLcLPrinterlEDataObjectgR_TClassManip(TClass*);
2738  static void *new_GaudiPythoncLcLPrinterlEDataObjectgR(void *p = 0);
2739  static void *newArray_GaudiPythoncLcLPrinterlEDataObjectgR(Long_t size, void *p);
2740  static void delete_GaudiPythoncLcLPrinterlEDataObjectgR(void *p);
2741  static void deleteArray_GaudiPythoncLcLPrinterlEDataObjectgR(void *p);
2742  static void destruct_GaudiPythoncLcLPrinterlEDataObjectgR(void *p);
2743 
2744  // Function generating the singleton type initializer
2745  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::Printer<DataObject>*)
2746  {
2747  ::GaudiPython::Printer<DataObject> *ptr = 0;
2748  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::Printer<DataObject>));
2749  static ::ROOT::TGenericClassInfo
2750  instance("GaudiPython::Printer<DataObject>", "GaudiPython/Printer.h", 44,
2751  typeid(::GaudiPython::Printer<DataObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2752  &GaudiPythoncLcLPrinterlEDataObjectgR_Dictionary, isa_proxy, 4,
2753  sizeof(::GaudiPython::Printer<DataObject>) );
2754  instance.SetNew(&new_GaudiPythoncLcLPrinterlEDataObjectgR);
2755  instance.SetNewArray(&newArray_GaudiPythoncLcLPrinterlEDataObjectgR);
2756  instance.SetDelete(&delete_GaudiPythoncLcLPrinterlEDataObjectgR);
2757  instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLPrinterlEDataObjectgR);
2758  instance.SetDestructor(&destruct_GaudiPythoncLcLPrinterlEDataObjectgR);
2759  return &instance;
2760  }
2761  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::Printer<DataObject>*)
2762  {
2763  return GenerateInitInstanceLocal((::GaudiPython::Printer<DataObject>*)0);
2764  }
2765  // Static variable to force the class initialization
2766  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::Printer<DataObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2767 
2768  // Dictionary for non-ClassDef classes
2769  static TClass *GaudiPythoncLcLPrinterlEDataObjectgR_Dictionary() {
2770  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::Printer<DataObject>*)0x0)->GetClass();
2771  GaudiPythoncLcLPrinterlEDataObjectgR_TClassManip(theClass);
2772  return theClass;
2773  }
2774 
2775  static void GaudiPythoncLcLPrinterlEDataObjectgR_TClassManip(TClass* ){
2776  }
2777 
2778 } // end of namespace ROOT
2779 
2780 namespace ROOT {
2781  static TClass *TuplescLcLTuple_Dictionary();
2782  static void TuplescLcLTuple_TClassManip(TClass*);
2783  static void delete_TuplescLcLTuple(void *p);
2784  static void deleteArray_TuplescLcLTuple(void *p);
2785  static void destruct_TuplescLcLTuple(void *p);
2786 
2787  // Function generating the singleton type initializer
2788  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Tuples::Tuple*)
2789  {
2790  ::Tuples::Tuple *ptr = 0;
2791  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Tuples::Tuple));
2792  static ::ROOT::TGenericClassInfo
2793  instance("Tuples::Tuple", "GaudiAlg/Tuple.h", 117,
2794  typeid(::Tuples::Tuple), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2795  &TuplescLcLTuple_Dictionary, isa_proxy, 4,
2796  sizeof(::Tuples::Tuple) );
2797  instance.SetDelete(&delete_TuplescLcLTuple);
2798  instance.SetDeleteArray(&deleteArray_TuplescLcLTuple);
2799  instance.SetDestructor(&destruct_TuplescLcLTuple);
2800  return &instance;
2801  }
2802  TGenericClassInfo *GenerateInitInstance(const ::Tuples::Tuple*)
2803  {
2804  return GenerateInitInstanceLocal((::Tuples::Tuple*)0);
2805  }
2806  // Static variable to force the class initialization
2807  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Tuples::Tuple*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2808 
2809  // Dictionary for non-ClassDef classes
2810  static TClass *TuplescLcLTuple_Dictionary() {
2811  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Tuples::Tuple*)0x0)->GetClass();
2812  TuplescLcLTuple_TClassManip(theClass);
2813  return theClass;
2814  }
2815 
2816  static void TuplescLcLTuple_TClassManip(TClass* ){
2817  }
2818 
2819 } // end of namespace ROOT
2820 
2821 namespace ROOT {
2822  static TClass *GaudiTupleslEGaudiHistoAlggR_Dictionary();
2823  static void GaudiTupleslEGaudiHistoAlggR_TClassManip(TClass*);
2824  static void delete_GaudiTupleslEGaudiHistoAlggR(void *p);
2825  static void deleteArray_GaudiTupleslEGaudiHistoAlggR(void *p);
2826  static void destruct_GaudiTupleslEGaudiHistoAlggR(void *p);
2827 
2828  // Function generating the singleton type initializer
2829  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiTuples<GaudiHistoAlg>*)
2830  {
2831  ::GaudiTuples<GaudiHistoAlg> *ptr = 0;
2832  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiTuples<GaudiHistoAlg>));
2833  static ::ROOT::TGenericClassInfo
2834  instance("GaudiTuples<GaudiHistoAlg>", "GaudiAlg/GaudiTuples.h", 39,
2835  typeid(::GaudiTuples<GaudiHistoAlg>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2836  &GaudiTupleslEGaudiHistoAlggR_Dictionary, isa_proxy, 4,
2837  sizeof(::GaudiTuples<GaudiHistoAlg>) );
2838  instance.SetDelete(&delete_GaudiTupleslEGaudiHistoAlggR);
2839  instance.SetDeleteArray(&deleteArray_GaudiTupleslEGaudiHistoAlggR);
2840  instance.SetDestructor(&destruct_GaudiTupleslEGaudiHistoAlggR);
2841  return &instance;
2842  }
2843  TGenericClassInfo *GenerateInitInstance(const ::GaudiTuples<GaudiHistoAlg>*)
2844  {
2845  return GenerateInitInstanceLocal((::GaudiTuples<GaudiHistoAlg>*)0);
2846  }
2847  // Static variable to force the class initialization
2848  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiTuples<GaudiHistoAlg>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2849 
2850  // Dictionary for non-ClassDef classes
2851  static TClass *GaudiTupleslEGaudiHistoAlggR_Dictionary() {
2852  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiTuples<GaudiHistoAlg>*)0x0)->GetClass();
2853  GaudiTupleslEGaudiHistoAlggR_TClassManip(theClass);
2854  return theClass;
2855  }
2856 
2857  static void GaudiTupleslEGaudiHistoAlggR_TClassManip(TClass* ){
2858  }
2859 
2860 } // end of namespace ROOT
2861 
2862 namespace ROOT {
2863  static TClass *ITupleTool_Dictionary();
2864  static void ITupleTool_TClassManip(TClass*);
2865 
2866  // Function generating the singleton type initializer
2867  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ITupleTool*)
2868  {
2869  ::ITupleTool *ptr = 0;
2870  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ITupleTool));
2871  static ::ROOT::TGenericClassInfo
2872  instance("ITupleTool", "GaudiAlg/ITupleTool.h", 30,
2873  typeid(::ITupleTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2874  &ITupleTool_Dictionary, isa_proxy, 4,
2875  sizeof(::ITupleTool) );
2876  return &instance;
2877  }
2878  TGenericClassInfo *GenerateInitInstance(const ::ITupleTool*)
2879  {
2880  return GenerateInitInstanceLocal((::ITupleTool*)0);
2881  }
2882  // Static variable to force the class initialization
2883  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ITupleTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2884 
2885  // Dictionary for non-ClassDef classes
2886  static TClass *ITupleTool_Dictionary() {
2887  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ITupleTool*)0x0)->GetClass();
2888  ITupleTool_TClassManip(theClass);
2889  return theClass;
2890  }
2891 
2892  static void ITupleTool_TClassManip(TClass* ){
2893  }
2894 
2895 } // end of namespace ROOT
2896 
2897 namespace ROOT {
2898  static TClass *GaudiPythoncLcLTupleDecorator_Dictionary();
2899  static void GaudiPythoncLcLTupleDecorator_TClassManip(TClass*);
2900  static void *new_GaudiPythoncLcLTupleDecorator(void *p = 0);
2901  static void *newArray_GaudiPythoncLcLTupleDecorator(Long_t size, void *p);
2902  static void delete_GaudiPythoncLcLTupleDecorator(void *p);
2903  static void deleteArray_GaudiPythoncLcLTupleDecorator(void *p);
2904  static void destruct_GaudiPythoncLcLTupleDecorator(void *p);
2905 
2906  // Function generating the singleton type initializer
2907  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::TupleDecorator*)
2908  {
2909  ::GaudiPython::TupleDecorator *ptr = 0;
2910  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::TupleDecorator));
2911  static ::ROOT::TGenericClassInfo
2912  instance("GaudiPython::TupleDecorator", "GaudiPython/TupleDecorator.h", 46,
2913  typeid(::GaudiPython::TupleDecorator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2914  &GaudiPythoncLcLTupleDecorator_Dictionary, isa_proxy, 4,
2915  sizeof(::GaudiPython::TupleDecorator) );
2916  instance.SetNew(&new_GaudiPythoncLcLTupleDecorator);
2917  instance.SetNewArray(&newArray_GaudiPythoncLcLTupleDecorator);
2918  instance.SetDelete(&delete_GaudiPythoncLcLTupleDecorator);
2919  instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLTupleDecorator);
2920  instance.SetDestructor(&destruct_GaudiPythoncLcLTupleDecorator);
2921  return &instance;
2922  }
2923  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::TupleDecorator*)
2924  {
2925  return GenerateInitInstanceLocal((::GaudiPython::TupleDecorator*)0);
2926  }
2927  // Static variable to force the class initialization
2928  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::TupleDecorator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2929 
2930  // Dictionary for non-ClassDef classes
2931  static TClass *GaudiPythoncLcLTupleDecorator_Dictionary() {
2932  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::TupleDecorator*)0x0)->GetClass();
2933  GaudiPythoncLcLTupleDecorator_TClassManip(theClass);
2934  return theClass;
2935  }
2936 
2937  static void GaudiPythoncLcLTupleDecorator_TClassManip(TClass* ){
2938  }
2939 
2940 } // end of namespace ROOT
2941 
2942 namespace ROOT {
2943  static TClass *GaudiPythoncLcLTupleAlgDecorator_Dictionary();
2944  static void GaudiPythoncLcLTupleAlgDecorator_TClassManip(TClass*);
2945  static void *new_GaudiPythoncLcLTupleAlgDecorator(void *p = 0);
2946  static void *newArray_GaudiPythoncLcLTupleAlgDecorator(Long_t size, void *p);
2947  static void delete_GaudiPythoncLcLTupleAlgDecorator(void *p);
2948  static void deleteArray_GaudiPythoncLcLTupleAlgDecorator(void *p);
2949  static void destruct_GaudiPythoncLcLTupleAlgDecorator(void *p);
2950 
2951  // Function generating the singleton type initializer
2952  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::TupleAlgDecorator*)
2953  {
2954  ::GaudiPython::TupleAlgDecorator *ptr = 0;
2955  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::TupleAlgDecorator));
2956  static ::ROOT::TGenericClassInfo
2957  instance("GaudiPython::TupleAlgDecorator", "GaudiPython/TupleDecorator.h", 269,
2958  typeid(::GaudiPython::TupleAlgDecorator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2959  &GaudiPythoncLcLTupleAlgDecorator_Dictionary, isa_proxy, 4,
2960  sizeof(::GaudiPython::TupleAlgDecorator) );
2961  instance.SetNew(&new_GaudiPythoncLcLTupleAlgDecorator);
2962  instance.SetNewArray(&newArray_GaudiPythoncLcLTupleAlgDecorator);
2963  instance.SetDelete(&delete_GaudiPythoncLcLTupleAlgDecorator);
2964  instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLTupleAlgDecorator);
2965  instance.SetDestructor(&destruct_GaudiPythoncLcLTupleAlgDecorator);
2966  return &instance;
2967  }
2968  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::TupleAlgDecorator*)
2969  {
2970  return GenerateInitInstanceLocal((::GaudiPython::TupleAlgDecorator*)0);
2971  }
2972  // Static variable to force the class initialization
2973  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::TupleAlgDecorator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2974 
2975  // Dictionary for non-ClassDef classes
2976  static TClass *GaudiPythoncLcLTupleAlgDecorator_Dictionary() {
2977  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::TupleAlgDecorator*)0x0)->GetClass();
2978  GaudiPythoncLcLTupleAlgDecorator_TClassManip(theClass);
2979  return theClass;
2980  }
2981 
2982  static void GaudiPythoncLcLTupleAlgDecorator_TClassManip(TClass* ){
2983  }
2984 
2985 } // end of namespace ROOT
2986 
2987 namespace ROOT {
2988  static TClass *GaudiPythoncLcLTupleToolDecorator_Dictionary();
2989  static void GaudiPythoncLcLTupleToolDecorator_TClassManip(TClass*);
2990  static void *new_GaudiPythoncLcLTupleToolDecorator(void *p = 0);
2991  static void *newArray_GaudiPythoncLcLTupleToolDecorator(Long_t size, void *p);
2992  static void delete_GaudiPythoncLcLTupleToolDecorator(void *p);
2993  static void deleteArray_GaudiPythoncLcLTupleToolDecorator(void *p);
2994  static void destruct_GaudiPythoncLcLTupleToolDecorator(void *p);
2995 
2996  // Function generating the singleton type initializer
2997  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::TupleToolDecorator*)
2998  {
2999  ::GaudiPython::TupleToolDecorator *ptr = 0;
3000  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::TupleToolDecorator));
3001  static ::ROOT::TGenericClassInfo
3002  instance("GaudiPython::TupleToolDecorator", "GaudiPython/TupleDecorator.h", 312,
3003  typeid(::GaudiPython::TupleToolDecorator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3004  &GaudiPythoncLcLTupleToolDecorator_Dictionary, isa_proxy, 4,
3005  sizeof(::GaudiPython::TupleToolDecorator) );
3006  instance.SetNew(&new_GaudiPythoncLcLTupleToolDecorator);
3007  instance.SetNewArray(&newArray_GaudiPythoncLcLTupleToolDecorator);
3008  instance.SetDelete(&delete_GaudiPythoncLcLTupleToolDecorator);
3009  instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLTupleToolDecorator);
3010  instance.SetDestructor(&destruct_GaudiPythoncLcLTupleToolDecorator);
3011  return &instance;
3012  }
3013  TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::TupleToolDecorator*)
3014  {
3015  return GenerateInitInstanceLocal((::GaudiPython::TupleToolDecorator*)0);
3016  }
3017  // Static variable to force the class initialization
3018  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::TupleToolDecorator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3019 
3020  // Dictionary for non-ClassDef classes
3021  static TClass *GaudiPythoncLcLTupleToolDecorator_Dictionary() {
3022  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::TupleToolDecorator*)0x0)->GetClass();
3023  GaudiPythoncLcLTupleToolDecorator_TClassManip(theClass);
3024  return theClass;
3025  }
3026 
3027  static void GaudiPythoncLcLTupleToolDecorator_TClassManip(TClass* ){
3028  }
3029 
3030 } // end of namespace ROOT
3031 
3032 namespace ROOT {
3033  static TClass *GaudiAlgcLcLPrint_Dictionary();
3034  static void GaudiAlgcLcLPrint_TClassManip(TClass*);
3035  static void *new_GaudiAlgcLcLPrint(void *p = 0);
3036  static void *newArray_GaudiAlgcLcLPrint(Long_t size, void *p);
3037  static void delete_GaudiAlgcLcLPrint(void *p);
3038  static void deleteArray_GaudiAlgcLcLPrint(void *p);
3039  static void destruct_GaudiAlgcLcLPrint(void *p);
3040 
3041  // Function generating the singleton type initializer
3042  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::Print*)
3043  {
3044  ::GaudiAlg::Print *ptr = 0;
3045  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::Print));
3046  static ::ROOT::TGenericClassInfo
3047  instance("GaudiAlg::Print", "GaudiAlg/Print.h", 52,
3048  typeid(::GaudiAlg::Print), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3049  &GaudiAlgcLcLPrint_Dictionary, isa_proxy, 4,
3050  sizeof(::GaudiAlg::Print) );
3051  instance.SetNew(&new_GaudiAlgcLcLPrint);
3052  instance.SetNewArray(&newArray_GaudiAlgcLcLPrint);
3053  instance.SetDelete(&delete_GaudiAlgcLcLPrint);
3054  instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrint);
3055  instance.SetDestructor(&destruct_GaudiAlgcLcLPrint);
3056  return &instance;
3057  }
3058  TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::Print*)
3059  {
3060  return GenerateInitInstanceLocal((::GaudiAlg::Print*)0);
3061  }
3062  // Static variable to force the class initialization
3063  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::Print*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3064 
3065  // Dictionary for non-ClassDef classes
3066  static TClass *GaudiAlgcLcLPrint_Dictionary() {
3067  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::Print*)0x0)->GetClass();
3068  GaudiAlgcLcLPrint_TClassManip(theClass);
3069  return theClass;
3070  }
3071 
3072  static void GaudiAlgcLcLPrint_TClassManip(TClass* ){
3073  }
3074 
3075 } // end of namespace ROOT
3076 
3077 namespace ROOT {
3078  static TClass *GaudiAlgcLcLPrint1D_Dictionary();
3079  static void GaudiAlgcLcLPrint1D_TClassManip(TClass*);
3080  static void *new_GaudiAlgcLcLPrint1D(void *p = 0);
3081  static void *newArray_GaudiAlgcLcLPrint1D(Long_t size, void *p);
3082  static void delete_GaudiAlgcLcLPrint1D(void *p);
3083  static void deleteArray_GaudiAlgcLcLPrint1D(void *p);
3084  static void destruct_GaudiAlgcLcLPrint1D(void *p);
3085 
3086  // Function generating the singleton type initializer
3087  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::Print1D*)
3088  {
3089  ::GaudiAlg::Print1D *ptr = 0;
3090  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::Print1D));
3091  static ::ROOT::TGenericClassInfo
3092  instance("GaudiAlg::Print1D", "GaudiAlg/Print.h", 65,
3093  typeid(::GaudiAlg::Print1D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3094  &GaudiAlgcLcLPrint1D_Dictionary, isa_proxy, 4,
3095  sizeof(::GaudiAlg::Print1D) );
3096  instance.SetNew(&new_GaudiAlgcLcLPrint1D);
3097  instance.SetNewArray(&newArray_GaudiAlgcLcLPrint1D);
3098  instance.SetDelete(&delete_GaudiAlgcLcLPrint1D);
3099  instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrint1D);
3100  instance.SetDestructor(&destruct_GaudiAlgcLcLPrint1D);
3101  return &instance;
3102  }
3103  TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::Print1D*)
3104  {
3105  return GenerateInitInstanceLocal((::GaudiAlg::Print1D*)0);
3106  }
3107  // Static variable to force the class initialization
3108  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::Print1D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3109 
3110  // Dictionary for non-ClassDef classes
3111  static TClass *GaudiAlgcLcLPrint1D_Dictionary() {
3112  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::Print1D*)0x0)->GetClass();
3113  GaudiAlgcLcLPrint1D_TClassManip(theClass);
3114  return theClass;
3115  }
3116 
3117  static void GaudiAlgcLcLPrint1D_TClassManip(TClass* ){
3118  }
3119 
3120 } // end of namespace ROOT
3121 
3122 namespace ROOT {
3123  static TClass *GaudiAlgcLcLPrint2D_Dictionary();
3124  static void GaudiAlgcLcLPrint2D_TClassManip(TClass*);
3125  static void *new_GaudiAlgcLcLPrint2D(void *p = 0);
3126  static void *newArray_GaudiAlgcLcLPrint2D(Long_t size, void *p);
3127  static void delete_GaudiAlgcLcLPrint2D(void *p);
3128  static void deleteArray_GaudiAlgcLcLPrint2D(void *p);
3129  static void destruct_GaudiAlgcLcLPrint2D(void *p);
3130 
3131  // Function generating the singleton type initializer
3132  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::Print2D*)
3133  {
3134  ::GaudiAlg::Print2D *ptr = 0;
3135  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::Print2D));
3136  static ::ROOT::TGenericClassInfo
3137  instance("GaudiAlg::Print2D", "GaudiAlg/Print.h", 80,
3138  typeid(::GaudiAlg::Print2D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3139  &GaudiAlgcLcLPrint2D_Dictionary, isa_proxy, 4,
3140  sizeof(::GaudiAlg::Print2D) );
3141  instance.SetNew(&new_GaudiAlgcLcLPrint2D);
3142  instance.SetNewArray(&newArray_GaudiAlgcLcLPrint2D);
3143  instance.SetDelete(&delete_GaudiAlgcLcLPrint2D);
3144  instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrint2D);
3145  instance.SetDestructor(&destruct_GaudiAlgcLcLPrint2D);
3146  return &instance;
3147  }
3148  TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::Print2D*)
3149  {
3150  return GenerateInitInstanceLocal((::GaudiAlg::Print2D*)0);
3151  }
3152  // Static variable to force the class initialization
3153  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::Print2D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3154 
3155  // Dictionary for non-ClassDef classes
3156  static TClass *GaudiAlgcLcLPrint2D_Dictionary() {
3157  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::Print2D*)0x0)->GetClass();
3158  GaudiAlgcLcLPrint2D_TClassManip(theClass);
3159  return theClass;
3160  }
3161 
3162  static void GaudiAlgcLcLPrint2D_TClassManip(TClass* ){
3163  }
3164 
3165 } // end of namespace ROOT
3166 
3167 namespace ROOT {
3168  static TClass *GaudiAlgcLcLPrint3D_Dictionary();
3169  static void GaudiAlgcLcLPrint3D_TClassManip(TClass*);
3170  static void *new_GaudiAlgcLcLPrint3D(void *p = 0);
3171  static void *newArray_GaudiAlgcLcLPrint3D(Long_t size, void *p);
3172  static void delete_GaudiAlgcLcLPrint3D(void *p);
3173  static void deleteArray_GaudiAlgcLcLPrint3D(void *p);
3174  static void destruct_GaudiAlgcLcLPrint3D(void *p);
3175 
3176  // Function generating the singleton type initializer
3177  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::Print3D*)
3178  {
3179  ::GaudiAlg::Print3D *ptr = 0;
3180  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::Print3D));
3181  static ::ROOT::TGenericClassInfo
3182  instance("GaudiAlg::Print3D", "GaudiAlg/Print.h", 96,
3183  typeid(::GaudiAlg::Print3D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3184  &GaudiAlgcLcLPrint3D_Dictionary, isa_proxy, 4,
3185  sizeof(::GaudiAlg::Print3D) );
3186  instance.SetNew(&new_GaudiAlgcLcLPrint3D);
3187  instance.SetNewArray(&newArray_GaudiAlgcLcLPrint3D);
3188  instance.SetDelete(&delete_GaudiAlgcLcLPrint3D);
3189  instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrint3D);
3190  instance.SetDestructor(&destruct_GaudiAlgcLcLPrint3D);
3191  return &instance;
3192  }
3193  TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::Print3D*)
3194  {
3195  return GenerateInitInstanceLocal((::GaudiAlg::Print3D*)0);
3196  }
3197  // Static variable to force the class initialization
3198  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::Print3D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3199 
3200  // Dictionary for non-ClassDef classes
3201  static TClass *GaudiAlgcLcLPrint3D_Dictionary() {
3202  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::Print3D*)0x0)->GetClass();
3203  GaudiAlgcLcLPrint3D_TClassManip(theClass);
3204  return theClass;
3205  }
3206 
3207  static void GaudiAlgcLcLPrint3D_TClassManip(TClass* ){
3208  }
3209 
3210 } // end of namespace ROOT
3211 
3212 namespace ROOT {
3213  static TClass *GaudiAlgcLcLPrint1DProf_Dictionary();
3214  static void GaudiAlgcLcLPrint1DProf_TClassManip(TClass*);
3215  static void *new_GaudiAlgcLcLPrint1DProf(void *p = 0);
3216  static void *newArray_GaudiAlgcLcLPrint1DProf(Long_t size, void *p);
3217  static void delete_GaudiAlgcLcLPrint1DProf(void *p);
3218  static void deleteArray_GaudiAlgcLcLPrint1DProf(void *p);
3219  static void destruct_GaudiAlgcLcLPrint1DProf(void *p);
3220 
3221  // Function generating the singleton type initializer
3222  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::Print1DProf*)
3223  {
3224  ::GaudiAlg::Print1DProf *ptr = 0;
3225  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::Print1DProf));
3226  static ::ROOT::TGenericClassInfo
3227  instance("GaudiAlg::Print1DProf", "GaudiAlg/Print.h", 112,
3228  typeid(::GaudiAlg::Print1DProf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3229  &GaudiAlgcLcLPrint1DProf_Dictionary, isa_proxy, 4,
3230  sizeof(::GaudiAlg::Print1DProf) );
3231  instance.SetNew(&new_GaudiAlgcLcLPrint1DProf);
3232  instance.SetNewArray(&newArray_GaudiAlgcLcLPrint1DProf);
3233  instance.SetDelete(&delete_GaudiAlgcLcLPrint1DProf);
3234  instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrint1DProf);
3235  instance.SetDestructor(&destruct_GaudiAlgcLcLPrint1DProf);
3236  return &instance;
3237  }
3238  TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::Print1DProf*)
3239  {
3240  return GenerateInitInstanceLocal((::GaudiAlg::Print1DProf*)0);
3241  }
3242  // Static variable to force the class initialization
3243  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::Print1DProf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3244 
3245  // Dictionary for non-ClassDef classes
3246  static TClass *GaudiAlgcLcLPrint1DProf_Dictionary() {
3247  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::Print1DProf*)0x0)->GetClass();
3248  GaudiAlgcLcLPrint1DProf_TClassManip(theClass);
3249  return theClass;
3250  }
3251 
3252  static void GaudiAlgcLcLPrint1DProf_TClassManip(TClass* ){
3253  }
3254 
3255 } // end of namespace ROOT
3256 
3257 namespace ROOT {
3258  static TClass *GaudiAlgcLcLPrint2DProf_Dictionary();
3259  static void GaudiAlgcLcLPrint2DProf_TClassManip(TClass*);
3260  static void *new_GaudiAlgcLcLPrint2DProf(void *p = 0);
3261  static void *newArray_GaudiAlgcLcLPrint2DProf(Long_t size, void *p);
3262  static void delete_GaudiAlgcLcLPrint2DProf(void *p);
3263  static void deleteArray_GaudiAlgcLcLPrint2DProf(void *p);
3264  static void destruct_GaudiAlgcLcLPrint2DProf(void *p);
3265 
3266  // Function generating the singleton type initializer
3267  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::Print2DProf*)
3268  {
3269  ::GaudiAlg::Print2DProf *ptr = 0;
3270  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::Print2DProf));
3271  static ::ROOT::TGenericClassInfo
3272  instance("GaudiAlg::Print2DProf", "GaudiAlg/Print.h", 128,
3273  typeid(::GaudiAlg::Print2DProf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3274  &GaudiAlgcLcLPrint2DProf_Dictionary, isa_proxy, 4,
3275  sizeof(::GaudiAlg::Print2DProf) );
3276  instance.SetNew(&new_GaudiAlgcLcLPrint2DProf);
3277  instance.SetNewArray(&newArray_GaudiAlgcLcLPrint2DProf);
3278  instance.SetDelete(&delete_GaudiAlgcLcLPrint2DProf);
3279  instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrint2DProf);
3280  instance.SetDestructor(&destruct_GaudiAlgcLcLPrint2DProf);
3281  return &instance;
3282  }
3283  TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::Print2DProf*)
3284  {
3285  return GenerateInitInstanceLocal((::GaudiAlg::Print2DProf*)0);
3286  }
3287  // Static variable to force the class initialization
3288  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::Print2DProf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3289 
3290  // Dictionary for non-ClassDef classes
3291  static TClass *GaudiAlgcLcLPrint2DProf_Dictionary() {
3292  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::Print2DProf*)0x0)->GetClass();
3293  GaudiAlgcLcLPrint2DProf_TClassManip(theClass);
3294  return theClass;
3295  }
3296 
3297  static void GaudiAlgcLcLPrint2DProf_TClassManip(TClass* ){
3298  }
3299 
3300 } // end of namespace ROOT
3301 
3302 namespace ROOT {
3303  static TClass *GaudiAlgcLcLPrintTuple_Dictionary();
3304  static void GaudiAlgcLcLPrintTuple_TClassManip(TClass*);
3305  static void *new_GaudiAlgcLcLPrintTuple(void *p = 0);
3306  static void *newArray_GaudiAlgcLcLPrintTuple(Long_t size, void *p);
3307  static void delete_GaudiAlgcLcLPrintTuple(void *p);
3308  static void deleteArray_GaudiAlgcLcLPrintTuple(void *p);
3309  static void destruct_GaudiAlgcLcLPrintTuple(void *p);
3310 
3311  // Function generating the singleton type initializer
3312  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::PrintTuple*)
3313  {
3314  ::GaudiAlg::PrintTuple *ptr = 0;
3315  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::PrintTuple));
3316  static ::ROOT::TGenericClassInfo
3317  instance("GaudiAlg::PrintTuple", "GaudiAlg/Print.h", 145,
3318  typeid(::GaudiAlg::PrintTuple), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3319  &GaudiAlgcLcLPrintTuple_Dictionary, isa_proxy, 4,
3320  sizeof(::GaudiAlg::PrintTuple) );
3321  instance.SetNew(&new_GaudiAlgcLcLPrintTuple);
3322  instance.SetNewArray(&newArray_GaudiAlgcLcLPrintTuple);
3323  instance.SetDelete(&delete_GaudiAlgcLcLPrintTuple);
3324  instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrintTuple);
3325  instance.SetDestructor(&destruct_GaudiAlgcLcLPrintTuple);
3326  return &instance;
3327  }
3328  TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::PrintTuple*)
3329  {
3330  return GenerateInitInstanceLocal((::GaudiAlg::PrintTuple*)0);
3331  }
3332  // Static variable to force the class initialization
3333  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::PrintTuple*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3334 
3335  // Dictionary for non-ClassDef classes
3336  static TClass *GaudiAlgcLcLPrintTuple_Dictionary() {
3337  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::PrintTuple*)0x0)->GetClass();
3338  GaudiAlgcLcLPrintTuple_TClassManip(theClass);
3339  return theClass;
3340  }
3341 
3342  static void GaudiAlgcLcLPrintTuple_TClassManip(TClass* ){
3343  }
3344 
3345 } // end of namespace ROOT
3346 
3347 namespace ROOT {
3348  static TClass *GaudiAlgcLcLPrintStat_Dictionary();
3349  static void GaudiAlgcLcLPrintStat_TClassManip(TClass*);
3350  static void *new_GaudiAlgcLcLPrintStat(void *p = 0);
3351  static void *newArray_GaudiAlgcLcLPrintStat(Long_t size, void *p);
3352  static void delete_GaudiAlgcLcLPrintStat(void *p);
3353  static void deleteArray_GaudiAlgcLcLPrintStat(void *p);
3354  static void destruct_GaudiAlgcLcLPrintStat(void *p);
3355 
3356  // Function generating the singleton type initializer
3357  static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::PrintStat*)
3358  {
3359  ::GaudiAlg::PrintStat *ptr = 0;
3360  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::PrintStat));
3361  static ::ROOT::TGenericClassInfo
3362  instance("GaudiAlg::PrintStat", "GaudiAlg/Print.h", 162,
3363  typeid(::GaudiAlg::PrintStat), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3364  &GaudiAlgcLcLPrintStat_Dictionary, isa_proxy, 4,
3365  sizeof(::GaudiAlg::PrintStat) );
3366  instance.SetNew(&new_GaudiAlgcLcLPrintStat);
3367  instance.SetNewArray(&newArray_GaudiAlgcLcLPrintStat);
3368  instance.SetDelete(&delete_GaudiAlgcLcLPrintStat);
3369  instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrintStat);
3370  instance.SetDestructor(&destruct_GaudiAlgcLcLPrintStat);
3371  return &instance;
3372  }
3373  TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::PrintStat*)
3374  {
3375  return GenerateInitInstanceLocal((::GaudiAlg::PrintStat*)0);
3376  }
3377  // Static variable to force the class initialization
3378  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::PrintStat*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3379 
3380  // Dictionary for non-ClassDef classes
3381  static TClass *GaudiAlgcLcLPrintStat_Dictionary() {
3382  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::PrintStat*)0x0)->GetClass();
3383  GaudiAlgcLcLPrintStat_TClassManip(theClass);
3384  return theClass;
3385  }
3386 
3387  static void GaudiAlgcLcLPrintStat_TClassManip(TClass* ){
3388  }
3389 
3390 } // end of namespace ROOT
3391 
3392 namespace ROOT {
3393  static TClass *IErrorTool_Dictionary();
3394  static void IErrorTool_TClassManip(TClass*);
3395 
3396  // Function generating the singleton type initializer
3397  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IErrorTool*)
3398  {
3399  ::IErrorTool *ptr = 0;
3400  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IErrorTool));
3401  static ::ROOT::TGenericClassInfo
3402  instance("IErrorTool", "GaudiAlg/IErrorTool.h", 24,
3403  typeid(::IErrorTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3404  &IErrorTool_Dictionary, isa_proxy, 4,
3405  sizeof(::IErrorTool) );
3406  return &instance;
3407  }
3408  TGenericClassInfo *GenerateInitInstance(const ::IErrorTool*)
3409  {
3410  return GenerateInitInstanceLocal((::IErrorTool*)0);
3411  }
3412  // Static variable to force the class initialization
3413  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IErrorTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3414 
3415  // Dictionary for non-ClassDef classes
3416  static TClass *IErrorTool_Dictionary() {
3417  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IErrorTool*)0x0)->GetClass();
3418  IErrorTool_TClassManip(theClass);
3419  return theClass;
3420  }
3421 
3422  static void IErrorTool_TClassManip(TClass* ){
3423  }
3424 
3425 } // end of namespace ROOT
3426 
3427 namespace ROOT {
3428  static TClass *IGenericTool_Dictionary();
3429  static void IGenericTool_TClassManip(TClass*);
3430  static void delete_IGenericTool(void *p);
3431  static void deleteArray_IGenericTool(void *p);
3432  static void destruct_IGenericTool(void *p);
3433 
3434  // Function generating the singleton type initializer
3435  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IGenericTool*)
3436  {
3437  ::IGenericTool *ptr = 0;
3438  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IGenericTool));
3439  static ::ROOT::TGenericClassInfo
3440  instance("IGenericTool", "GaudiAlg/IGenericTool.h", 13,
3441  typeid(::IGenericTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3442  &IGenericTool_Dictionary, isa_proxy, 4,
3443  sizeof(::IGenericTool) );
3444  instance.SetDelete(&delete_IGenericTool);
3445  instance.SetDeleteArray(&deleteArray_IGenericTool);
3446  instance.SetDestructor(&destruct_IGenericTool);
3447  return &instance;
3448  }
3449  TGenericClassInfo *GenerateInitInstance(const ::IGenericTool*)
3450  {
3451  return GenerateInitInstanceLocal((::IGenericTool*)0);
3452  }
3453  // Static variable to force the class initialization
3454  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IGenericTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3455 
3456  // Dictionary for non-ClassDef classes
3457  static TClass *IGenericTool_Dictionary() {
3458  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IGenericTool*)0x0)->GetClass();
3459  IGenericTool_TClassManip(theClass);
3460  return theClass;
3461  }
3462 
3463  static void IGenericTool_TClassManip(TClass* ){
3464  }
3465 
3466 } // end of namespace ROOT
3467 
3468 namespace ROOT {
3469  static TClass *IHistoTool_Dictionary();
3470  static void IHistoTool_TClassManip(TClass*);
3471 
3472  // Function generating the singleton type initializer
3473  static TGenericClassInfo *GenerateInitInstanceLocal(const ::IHistoTool*)
3474  {
3475  ::IHistoTool *ptr = 0;
3476  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IHistoTool));
3477  static ::ROOT::TGenericClassInfo
3478  instance("IHistoTool", "GaudiAlg/IHistoTool.h", 31,
3479  typeid(::IHistoTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3480  &IHistoTool_Dictionary, isa_proxy, 4,
3481  sizeof(::IHistoTool) );
3482  return &instance;
3483  }
3484  TGenericClassInfo *GenerateInitInstance(const ::IHistoTool*)
3485  {
3486  return GenerateInitInstanceLocal((::IHistoTool*)0);
3487  }
3488  // Static variable to force the class initialization
3489  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IHistoTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3490 
3491  // Dictionary for non-ClassDef classes
3492  static TClass *IHistoTool_Dictionary() {
3493  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IHistoTool*)0x0)->GetClass();
3494  IHistoTool_TClassManip(theClass);
3495  return theClass;
3496  }
3497 
3498  static void IHistoTool_TClassManip(TClass* ){
3499  }
3500 
3501 } // end of namespace ROOT
3502 
3503 namespace ROOT {
3504  static TClass *ISequencerTimerTool_Dictionary();
3505  static void ISequencerTimerTool_TClassManip(TClass*);
3506  static void delete_ISequencerTimerTool(void *p);
3507  static void deleteArray_ISequencerTimerTool(void *p);
3508  static void destruct_ISequencerTimerTool(void *p);
3509 
3510  // Function generating the singleton type initializer
3511  static TGenericClassInfo *GenerateInitInstanceLocal(const ::ISequencerTimerTool*)
3512  {
3513  ::ISequencerTimerTool *ptr = 0;
3514  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ISequencerTimerTool));
3515  static ::ROOT::TGenericClassInfo
3516  instance("ISequencerTimerTool", "GaudiAlg/ISequencerTimerTool.h", 14,
3517  typeid(::ISequencerTimerTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3518  &ISequencerTimerTool_Dictionary, isa_proxy, 4,
3519  sizeof(::ISequencerTimerTool) );
3520  instance.SetDelete(&delete_ISequencerTimerTool);
3521  instance.SetDeleteArray(&deleteArray_ISequencerTimerTool);
3522  instance.SetDestructor(&destruct_ISequencerTimerTool);
3523  return &instance;
3524  }
3525  TGenericClassInfo *GenerateInitInstance(const ::ISequencerTimerTool*)
3526  {
3527  return GenerateInitInstanceLocal((::ISequencerTimerTool*)0);
3528  }
3529  // Static variable to force the class initialization
3530  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ISequencerTimerTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3531 
3532  // Dictionary for non-ClassDef classes
3533  static TClass *ISequencerTimerTool_Dictionary() {
3534  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ISequencerTimerTool*)0x0)->GetClass();
3535  ISequencerTimerTool_TClassManip(theClass);
3536  return theClass;
3537  }
3538 
3539  static void ISequencerTimerTool_TClassManip(TClass* ){
3540  }
3541 
3542 } // end of namespace ROOT
3543 
3544 namespace ROOT {
3545  static TClass *GaudicLcLUtilscLcLAida2ROOT_Dictionary();
3546  static void GaudicLcLUtilscLcLAida2ROOT_TClassManip(TClass*);
3547  static void *new_GaudicLcLUtilscLcLAida2ROOT(void *p = 0);
3548  static void *newArray_GaudicLcLUtilscLcLAida2ROOT(Long_t size, void *p);
3549  static void delete_GaudicLcLUtilscLcLAida2ROOT(void *p);
3550  static void deleteArray_GaudicLcLUtilscLcLAida2ROOT(void *p);
3551  static void destruct_GaudicLcLUtilscLcLAida2ROOT(void *p);
3552 
3553  // Function generating the singleton type initializer
3554  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Utils::Aida2ROOT*)
3555  {
3556  ::Gaudi::Utils::Aida2ROOT *ptr = 0;
3557  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Utils::Aida2ROOT));
3558  static ::ROOT::TGenericClassInfo
3559  instance("Gaudi::Utils::Aida2ROOT", "GaudiUtils/Aida2ROOT.h", 60,
3560  typeid(::Gaudi::Utils::Aida2ROOT), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3561  &GaudicLcLUtilscLcLAida2ROOT_Dictionary, isa_proxy, 4,
3562  sizeof(::Gaudi::Utils::Aida2ROOT) );
3563  instance.SetNew(&new_GaudicLcLUtilscLcLAida2ROOT);
3564  instance.SetNewArray(&newArray_GaudicLcLUtilscLcLAida2ROOT);
3565  instance.SetDelete(&delete_GaudicLcLUtilscLcLAida2ROOT);
3566  instance.SetDeleteArray(&deleteArray_GaudicLcLUtilscLcLAida2ROOT);
3567  instance.SetDestructor(&destruct_GaudicLcLUtilscLcLAida2ROOT);
3568  return &instance;
3569  }
3570  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Utils::Aida2ROOT*)
3571  {
3572  return GenerateInitInstanceLocal((::Gaudi::Utils::Aida2ROOT*)0);
3573  }
3574  // Static variable to force the class initialization
3575  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Utils::Aida2ROOT*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3576 
3577  // Dictionary for non-ClassDef classes
3578  static TClass *GaudicLcLUtilscLcLAida2ROOT_Dictionary() {
3579  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Utils::Aida2ROOT*)0x0)->GetClass();
3580  GaudicLcLUtilscLcLAida2ROOT_TClassManip(theClass);
3581  return theClass;
3582  }
3583 
3584  static void GaudicLcLUtilscLcLAida2ROOT_TClassManip(TClass* ){
3585  }
3586 
3587 } // end of namespace ROOT
3588 
3589 namespace ROOT {
3590  static TClass *GaudicLcLUtilscLcLHistoStats_Dictionary();
3591  static void GaudicLcLUtilscLcLHistoStats_TClassManip(TClass*);
3592  static void *new_GaudicLcLUtilscLcLHistoStats(void *p = 0);
3593  static void *newArray_GaudicLcLUtilscLcLHistoStats(Long_t size, void *p);
3594  static void delete_GaudicLcLUtilscLcLHistoStats(void *p);
3595  static void deleteArray_GaudicLcLUtilscLcLHistoStats(void *p);
3596  static void destruct_GaudicLcLUtilscLcLHistoStats(void *p);
3597 
3598  // Function generating the singleton type initializer
3599  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Utils::HistoStats*)
3600  {
3601  ::Gaudi::Utils::HistoStats *ptr = 0;
3602  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Utils::HistoStats));
3603  static ::ROOT::TGenericClassInfo
3604  instance("Gaudi::Utils::HistoStats", "GaudiUtils/HistoStats.h", 32,
3605  typeid(::Gaudi::Utils::HistoStats), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3606  &GaudicLcLUtilscLcLHistoStats_Dictionary, isa_proxy, 4,
3607  sizeof(::Gaudi::Utils::HistoStats) );
3608  instance.SetNew(&new_GaudicLcLUtilscLcLHistoStats);
3609  instance.SetNewArray(&newArray_GaudicLcLUtilscLcLHistoStats);
3610  instance.SetDelete(&delete_GaudicLcLUtilscLcLHistoStats);
3611  instance.SetDeleteArray(&deleteArray_GaudicLcLUtilscLcLHistoStats);
3612  instance.SetDestructor(&destruct_GaudicLcLUtilscLcLHistoStats);
3613  return &instance;
3614  }
3615  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Utils::HistoStats*)
3616  {
3617  return GenerateInitInstanceLocal((::Gaudi::Utils::HistoStats*)0);
3618  }
3619  // Static variable to force the class initialization
3620  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Utils::HistoStats*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3621 
3622  // Dictionary for non-ClassDef classes
3623  static TClass *GaudicLcLUtilscLcLHistoStats_Dictionary() {
3624  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Utils::HistoStats*)0x0)->GetClass();
3625  GaudicLcLUtilscLcLHistoStats_TClassManip(theClass);
3626  return theClass;
3627  }
3628 
3629  static void GaudicLcLUtilscLcLHistoStats_TClassManip(TClass* ){
3630  }
3631 
3632 } // end of namespace ROOT
3633 
3634 namespace ROOT {
3635  static TClass *GaudicLcLUtilscLcLHistoscLcLHistoStrings_Dictionary();
3636  static void GaudicLcLUtilscLcLHistoscLcLHistoStrings_TClassManip(TClass*);
3637  static void *new_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p = 0);
3638  static void *newArray_GaudicLcLUtilscLcLHistoscLcLHistoStrings(Long_t size, void *p);
3639  static void delete_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p);
3640  static void deleteArray_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p);
3641  static void destruct_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p);
3642 
3643  // Function generating the singleton type initializer
3644  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Utils::Histos::HistoStrings*)
3645  {
3646  ::Gaudi::Utils::Histos::HistoStrings *ptr = 0;
3647  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Utils::Histos::HistoStrings));
3648  static ::ROOT::TGenericClassInfo
3649  instance("Gaudi::Utils::Histos::HistoStrings", "GaudiUtils/HistoStrings.h", 52,
3650  typeid(::Gaudi::Utils::Histos::HistoStrings), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3651  &GaudicLcLUtilscLcLHistoscLcLHistoStrings_Dictionary, isa_proxy, 4,
3652  sizeof(::Gaudi::Utils::Histos::HistoStrings) );
3653  instance.SetNew(&new_GaudicLcLUtilscLcLHistoscLcLHistoStrings);
3654  instance.SetNewArray(&newArray_GaudicLcLUtilscLcLHistoscLcLHistoStrings);
3655  instance.SetDelete(&delete_GaudicLcLUtilscLcLHistoscLcLHistoStrings);
3656  instance.SetDeleteArray(&deleteArray_GaudicLcLUtilscLcLHistoscLcLHistoStrings);
3657  instance.SetDestructor(&destruct_GaudicLcLUtilscLcLHistoscLcLHistoStrings);
3658  return &instance;
3659  }
3660  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Utils::Histos::HistoStrings*)
3661  {
3662  return GenerateInitInstanceLocal((::Gaudi::Utils::Histos::HistoStrings*)0);
3663  }
3664  // Static variable to force the class initialization
3665  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Utils::Histos::HistoStrings*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3666 
3667  // Dictionary for non-ClassDef classes
3668  static TClass *GaudicLcLUtilscLcLHistoscLcLHistoStrings_Dictionary() {
3669  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Utils::Histos::HistoStrings*)0x0)->GetClass();
3670  GaudicLcLUtilscLcLHistoscLcLHistoStrings_TClassManip(theClass);
3671  return theClass;
3672  }
3673 
3674  static void GaudicLcLUtilscLcLHistoscLcLHistoStrings_TClassManip(TClass* ){
3675  }
3676 
3677 } // end of namespace ROOT
3678 
3679 namespace ROOT {
3680  static TClass *GaudicLcLIFileCatalog_Dictionary();
3681  static void GaudicLcLIFileCatalog_TClassManip(TClass*);
3682  static void delete_GaudicLcLIFileCatalog(void *p);
3683  static void deleteArray_GaudicLcLIFileCatalog(void *p);
3684  static void destruct_GaudicLcLIFileCatalog(void *p);
3685 
3686  // Function generating the singleton type initializer
3687  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::IFileCatalog*)
3688  {
3689  ::Gaudi::IFileCatalog *ptr = 0;
3690  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::IFileCatalog));
3691  static ::ROOT::TGenericClassInfo
3692  instance("Gaudi::IFileCatalog", "GaudiUtils/IFileCatalog.h", 25,
3693  typeid(::Gaudi::IFileCatalog), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3694  &GaudicLcLIFileCatalog_Dictionary, isa_proxy, 4,
3695  sizeof(::Gaudi::IFileCatalog) );
3696  instance.SetDelete(&delete_GaudicLcLIFileCatalog);
3697  instance.SetDeleteArray(&deleteArray_GaudicLcLIFileCatalog);
3698  instance.SetDestructor(&destruct_GaudicLcLIFileCatalog);
3699  return &instance;
3700  }
3701  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::IFileCatalog*)
3702  {
3703  return GenerateInitInstanceLocal((::Gaudi::IFileCatalog*)0);
3704  }
3705  // Static variable to force the class initialization
3706  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::IFileCatalog*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3707 
3708  // Dictionary for non-ClassDef classes
3709  static TClass *GaudicLcLIFileCatalog_Dictionary() {
3710  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::IFileCatalog*)0x0)->GetClass();
3711  GaudicLcLIFileCatalog_TClassManip(theClass);
3712  return theClass;
3713  }
3714 
3715  static void GaudicLcLIFileCatalog_TClassManip(TClass* ){
3716  }
3717 
3718 } // end of namespace ROOT
3719 
3720 namespace ROOT {
3721  static TClass *GaudicLcLIFileCatalogMgr_Dictionary();
3722  static void GaudicLcLIFileCatalogMgr_TClassManip(TClass*);
3723  static void delete_GaudicLcLIFileCatalogMgr(void *p);
3724  static void deleteArray_GaudicLcLIFileCatalogMgr(void *p);
3725  static void destruct_GaudicLcLIFileCatalogMgr(void *p);
3726 
3727  // Function generating the singleton type initializer
3728  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::IFileCatalogMgr*)
3729  {
3730  ::Gaudi::IFileCatalogMgr *ptr = 0;
3731  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::IFileCatalogMgr));
3732  static ::ROOT::TGenericClassInfo
3733  instance("Gaudi::IFileCatalogMgr", "GaudiUtils/IFileCatalogMgr.h", 27,
3734  typeid(::Gaudi::IFileCatalogMgr), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3735  &GaudicLcLIFileCatalogMgr_Dictionary, isa_proxy, 4,
3736  sizeof(::Gaudi::IFileCatalogMgr) );
3737  instance.SetDelete(&delete_GaudicLcLIFileCatalogMgr);
3738  instance.SetDeleteArray(&deleteArray_GaudicLcLIFileCatalogMgr);
3739  instance.SetDestructor(&destruct_GaudicLcLIFileCatalogMgr);
3740  return &instance;
3741  }
3742  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::IFileCatalogMgr*)
3743  {
3744  return GenerateInitInstanceLocal((::Gaudi::IFileCatalogMgr*)0);
3745  }
3746  // Static variable to force the class initialization
3747  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::IFileCatalogMgr*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3748 
3749  // Dictionary for non-ClassDef classes
3750  static TClass *GaudicLcLIFileCatalogMgr_Dictionary() {
3751  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::IFileCatalogMgr*)0x0)->GetClass();
3752  GaudicLcLIFileCatalogMgr_TClassManip(theClass);
3753  return theClass;
3754  }
3755 
3756  static void GaudicLcLIFileCatalogMgr_TClassManip(TClass* ){
3757  }
3758 
3759 } // end of namespace ROOT
3760 
3761 namespace ROOT {
3762  static TClass *GaudicLcLIDataConnection_Dictionary();
3763  static void GaudicLcLIDataConnection_TClassManip(TClass*);
3764  static void delete_GaudicLcLIDataConnection(void *p);
3765  static void deleteArray_GaudicLcLIDataConnection(void *p);
3766  static void destruct_GaudicLcLIDataConnection(void *p);
3767 
3768  // Function generating the singleton type initializer
3769  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::IDataConnection*)
3770  {
3771  ::Gaudi::IDataConnection *ptr = 0;
3772  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::IDataConnection));
3773  static ::ROOT::TGenericClassInfo
3774  instance("Gaudi::IDataConnection", "GaudiUtils/IIODataManager.h", 25,
3775  typeid(::Gaudi::IDataConnection), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3776  &GaudicLcLIDataConnection_Dictionary, isa_proxy, 4,
3777  sizeof(::Gaudi::IDataConnection) );
3778  instance.SetDelete(&delete_GaudicLcLIDataConnection);
3779  instance.SetDeleteArray(&deleteArray_GaudicLcLIDataConnection);
3780  instance.SetDestructor(&destruct_GaudicLcLIDataConnection);
3781  return &instance;
3782  }
3783  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::IDataConnection*)
3784  {
3785  return GenerateInitInstanceLocal((::Gaudi::IDataConnection*)0);
3786  }
3787  // Static variable to force the class initialization
3788  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::IDataConnection*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3789 
3790  // Dictionary for non-ClassDef classes
3791  static TClass *GaudicLcLIDataConnection_Dictionary() {
3792  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::IDataConnection*)0x0)->GetClass();
3793  GaudicLcLIDataConnection_TClassManip(theClass);
3794  return theClass;
3795  }
3796 
3797  static void GaudicLcLIDataConnection_TClassManip(TClass* ){
3798  }
3799 
3800 } // end of namespace ROOT
3801 
3802 namespace ROOT {
3803  static TClass *GaudicLcLIIODataManager_Dictionary();
3804  static void GaudicLcLIIODataManager_TClassManip(TClass*);
3805  static void delete_GaudicLcLIIODataManager(void *p);
3806  static void deleteArray_GaudicLcLIIODataManager(void *p);
3807  static void destruct_GaudicLcLIIODataManager(void *p);
3808 
3809  // Function generating the singleton type initializer
3810  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::IIODataManager*)
3811  {
3812  ::Gaudi::IIODataManager *ptr = 0;
3813  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::IIODataManager));
3814  static ::ROOT::TGenericClassInfo
3815  instance("Gaudi::IIODataManager", "GaudiUtils/IIODataManager.h", 90,
3816  typeid(::Gaudi::IIODataManager), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3817  &GaudicLcLIIODataManager_Dictionary, isa_proxy, 4,
3818  sizeof(::Gaudi::IIODataManager) );
3819  instance.SetDelete(&delete_GaudicLcLIIODataManager);
3820  instance.SetDeleteArray(&deleteArray_GaudicLcLIIODataManager);
3821  instance.SetDestructor(&destruct_GaudicLcLIIODataManager);
3822  return &instance;
3823  }
3824  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::IIODataManager*)
3825  {
3826  return GenerateInitInstanceLocal((::Gaudi::IIODataManager*)0);
3827  }
3828  // Static variable to force the class initialization
3829  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::IIODataManager*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3830 
3831  // Dictionary for non-ClassDef classes
3832  static TClass *GaudicLcLIIODataManager_Dictionary() {
3833  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::IIODataManager*)0x0)->GetClass();
3834  GaudicLcLIIODataManager_TClassManip(theClass);
3835  return theClass;
3836  }
3837 
3838  static void GaudicLcLIIODataManager_TClassManip(TClass* ){
3839  }
3840 
3841 } // end of namespace ROOT
3842 
3843 namespace ROOT {
3844  static TClass *__gnu_cxxcLcLdummy_Dictionary();
3845  static void __gnu_cxxcLcLdummy_TClassManip(TClass*);
3846  static void *new___gnu_cxxcLcLdummy(void *p = 0);
3847  static void *newArray___gnu_cxxcLcLdummy(Long_t size, void *p);
3848  static void delete___gnu_cxxcLcLdummy(void *p);
3849  static void deleteArray___gnu_cxxcLcLdummy(void *p);
3850  static void destruct___gnu_cxxcLcLdummy(void *p);
3851 
3852  // Function generating the singleton type initializer
3853  static TGenericClassInfo *GenerateInitInstanceLocal(const ::__gnu_cxx::dummy*)
3854  {
3855  ::__gnu_cxx::dummy *ptr = 0;
3856  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::__gnu_cxx::dummy));
3857  static ::ROOT::TGenericClassInfo
3858  instance("__gnu_cxx::dummy", "", 270,
3859  typeid(::__gnu_cxx::dummy), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3860  &__gnu_cxxcLcLdummy_Dictionary, isa_proxy, 4,
3861  sizeof(::__gnu_cxx::dummy) );
3862  instance.SetNew(&new___gnu_cxxcLcLdummy);
3863  instance.SetNewArray(&newArray___gnu_cxxcLcLdummy);
3864  instance.SetDelete(&delete___gnu_cxxcLcLdummy);
3865  instance.SetDeleteArray(&deleteArray___gnu_cxxcLcLdummy);
3866  instance.SetDestructor(&destruct___gnu_cxxcLcLdummy);
3867  return &instance;
3868  }
3869  TGenericClassInfo *GenerateInitInstance(const ::__gnu_cxx::dummy*)
3870  {
3871  return GenerateInitInstanceLocal((::__gnu_cxx::dummy*)0);
3872  }
3873  // Static variable to force the class initialization
3874  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::__gnu_cxx::dummy*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3875 
3876  // Dictionary for non-ClassDef classes
3877  static TClass *__gnu_cxxcLcLdummy_Dictionary() {
3878  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::__gnu_cxx::dummy*)0x0)->GetClass();
3879  __gnu_cxxcLcLdummy_TClassManip(theClass);
3880  return theClass;
3881  }
3882 
3883  static void __gnu_cxxcLcLdummy_TClassManip(TClass* ){
3884  }
3885 
3886 } // end of namespace ROOT
3887 
3888 namespace ROOT {
3889  // Wrappers around operator new
3890  static void *new_allocatorlEIServicemUgR(void *p) {
3891  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) allocator<IService*> : new allocator<IService*>;
3892  }
3893  static void *newArray_allocatorlEIServicemUgR(Long_t nElements, void *p) {
3894  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) allocator<IService*>[nElements] : new allocator<IService*>[nElements];
3895  }
3896  // Wrapper around operator delete
3897  static void delete_allocatorlEIServicemUgR(void *p) {
3898  delete ((allocator<IService*>*)p);
3899  }
3900  static void deleteArray_allocatorlEIServicemUgR(void *p) {
3901  delete [] ((allocator<IService*>*)p);
3902  }
3903  static void destruct_allocatorlEIServicemUgR(void *p) {
3904  typedef allocator<IService*> current_t;
3905  ((current_t*)p)->~current_t();
3906  }
3907 } // end of namespace ROOT for class allocator<IService*>
3908 
3909 namespace ROOT {
3910  // Wrappers around operator new
3911  static void *new_allocatorlEIAlgorithmmUgR(void *p) {
3912  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) allocator<IAlgorithm*> : new allocator<IAlgorithm*>;
3913  }
3914  static void *newArray_allocatorlEIAlgorithmmUgR(Long_t nElements, void *p) {
3915  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) allocator<IAlgorithm*>[nElements] : new allocator<IAlgorithm*>[nElements];
3916  }
3917  // Wrapper around operator delete
3918  static void delete_allocatorlEIAlgorithmmUgR(void *p) {
3919  delete ((allocator<IAlgorithm*>*)p);
3920  }
3921  static void deleteArray_allocatorlEIAlgorithmmUgR(void *p) {
3922  delete [] ((allocator<IAlgorithm*>*)p);
3923  }
3924  static void destruct_allocatorlEIAlgorithmmUgR(void *p) {
3925  typedef allocator<IAlgorithm*> current_t;
3926  ((current_t*)p)->~current_t();
3927  }
3928 } // end of namespace ROOT for class allocator<IAlgorithm*>
3929 
3930 namespace ROOT {
3931  // Wrappers around operator new
3932  static void *new_allocatorlEIRegistrymUgR(void *p) {
3933  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) allocator<IRegistry*> : new allocator<IRegistry*>;
3934  }
3935  static void *newArray_allocatorlEIRegistrymUgR(Long_t nElements, void *p) {
3936  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) allocator<IRegistry*>[nElements] : new allocator<IRegistry*>[nElements];
3937  }
3938  // Wrapper around operator delete
3939  static void delete_allocatorlEIRegistrymUgR(void *p) {
3940  delete ((allocator<IRegistry*>*)p);
3941  }
3942  static void deleteArray_allocatorlEIRegistrymUgR(void *p) {
3943  delete [] ((allocator<IRegistry*>*)p);
3944  }
3945  static void destruct_allocatorlEIRegistrymUgR(void *p) {
3946  typedef allocator<IRegistry*> current_t;
3947  ((current_t*)p)->~current_t();
3948  }
3949 } // end of namespace ROOT for class allocator<IRegistry*>
3950 
3951 namespace ROOT {
3952  // Wrapper around operator delete
3953  static void delete_basic_ostreamlEcharcOchar_traitslEchargRsPgR(void *p) {
3954  delete ((::basic_ostream<char,char_traits<char> >*)p);
3955  }
3956  static void deleteArray_basic_ostreamlEcharcOchar_traitslEchargRsPgR(void *p) {
3957  delete [] ((::basic_ostream<char,char_traits<char> >*)p);
3958  }
3959  static void destruct_basic_ostreamlEcharcOchar_traitslEchargRsPgR(void *p) {
3960  typedef ::basic_ostream<char,char_traits<char> > current_t;
3961  ((current_t*)p)->~current_t();
3962  }
3963 } // end of namespace ROOT for class ::basic_ostream<char,char_traits<char> >
3964 
3965 namespace ROOT {
3966  // Wrappers around operator new
3967  static void *new_unary_functionlEboolcOunsignedsPlonggR(void *p) {
3968  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<bool,unsigned long> : new ::unary_function<bool,unsigned long>;
3969  }
3970  static void *newArray_unary_functionlEboolcOunsignedsPlonggR(Long_t nElements, void *p) {
3971  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<bool,unsigned long>[nElements] : new ::unary_function<bool,unsigned long>[nElements];
3972  }
3973  // Wrapper around operator delete
3974  static void delete_unary_functionlEboolcOunsignedsPlonggR(void *p) {
3975  delete ((::unary_function<bool,unsigned long>*)p);
3976  }
3977  static void deleteArray_unary_functionlEboolcOunsignedsPlonggR(void *p) {
3978  delete [] ((::unary_function<bool,unsigned long>*)p);
3979  }
3980  static void destruct_unary_functionlEboolcOunsignedsPlonggR(void *p) {
3981  typedef ::unary_function<bool,unsigned long> current_t;
3982  ((current_t*)p)->~current_t();
3983  }
3984 } // end of namespace ROOT for class ::unary_function<bool,unsigned long>
3985 
3986 namespace ROOT {
3987  // Wrappers around operator new
3988  static void *new_unary_functionlEcharcOunsignedsPlonggR(void *p) {
3989  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<char,unsigned long> : new ::unary_function<char,unsigned long>;
3990  }
3991  static void *newArray_unary_functionlEcharcOunsignedsPlonggR(Long_t nElements, void *p) {
3992  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<char,unsigned long>[nElements] : new ::unary_function<char,unsigned long>[nElements];
3993  }
3994  // Wrapper around operator delete
3995  static void delete_unary_functionlEcharcOunsignedsPlonggR(void *p) {
3996  delete ((::unary_function<char,unsigned long>*)p);
3997  }
3998  static void deleteArray_unary_functionlEcharcOunsignedsPlonggR(void *p) {
3999  delete [] ((::unary_function<char,unsigned long>*)p);
4000  }
4001  static void destruct_unary_functionlEcharcOunsignedsPlonggR(void *p) {
4002  typedef ::unary_function<char,unsigned long> current_t;
4003  ((current_t*)p)->~current_t();
4004  }
4005 } // end of namespace ROOT for class ::unary_function<char,unsigned long>
4006 
4007 namespace ROOT {
4008  // Wrappers around operator new
4009  static void *new_unary_functionlEsignedsPcharcOunsignedsPlonggR(void *p) {
4010  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<signed char,unsigned long> : new ::unary_function<signed char,unsigned long>;
4011  }
4012  static void *newArray_unary_functionlEsignedsPcharcOunsignedsPlonggR(Long_t nElements, void *p) {
4013  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<signed char,unsigned long>[nElements] : new ::unary_function<signed char,unsigned long>[nElements];
4014  }
4015  // Wrapper around operator delete
4016  static void delete_unary_functionlEsignedsPcharcOunsignedsPlonggR(void *p) {
4017  delete ((::unary_function<signed char,unsigned long>*)p);
4018  }
4019  static void deleteArray_unary_functionlEsignedsPcharcOunsignedsPlonggR(void *p) {
4020  delete [] ((::unary_function<signed char,unsigned long>*)p);
4021  }
4022  static void destruct_unary_functionlEsignedsPcharcOunsignedsPlonggR(void *p) {
4023  typedef ::unary_function<signed char,unsigned long> current_t;
4024  ((current_t*)p)->~current_t();
4025  }
4026 } // end of namespace ROOT for class ::unary_function<signed char,unsigned long>
4027 
4028 namespace ROOT {
4029  // Wrappers around operator new
4030  static void *new_unary_functionlEunsignedsPcharcOunsignedsPlonggR(void *p) {
4031  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<unsigned char,unsigned long> : new ::unary_function<unsigned char,unsigned long>;
4032  }
4033  static void *newArray_unary_functionlEunsignedsPcharcOunsignedsPlonggR(Long_t nElements, void *p) {
4034  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<unsigned char,unsigned long>[nElements] : new ::unary_function<unsigned char,unsigned long>[nElements];
4035  }
4036  // Wrapper around operator delete
4037  static void delete_unary_functionlEunsignedsPcharcOunsignedsPlonggR(void *p) {
4038  delete ((::unary_function<unsigned char,unsigned long>*)p);
4039  }
4040  static void deleteArray_unary_functionlEunsignedsPcharcOunsignedsPlonggR(void *p) {
4041  delete [] ((::unary_function<unsigned char,unsigned long>*)p);
4042  }
4043  static void destruct_unary_functionlEunsignedsPcharcOunsignedsPlonggR(void *p) {
4044  typedef ::unary_function<unsigned char,unsigned long> current_t;
4045  ((current_t*)p)->~current_t();
4046  }
4047 } // end of namespace ROOT for class ::unary_function<unsigned char,unsigned long>
4048 
4049 namespace ROOT {
4050  // Wrappers around operator new
4051  static void *new_unary_functionlEwchar_tcOunsignedsPlonggR(void *p) {
4052  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<wchar_t,unsigned long> : new ::unary_function<wchar_t,unsigned long>;
4053  }
4054  static void *newArray_unary_functionlEwchar_tcOunsignedsPlonggR(Long_t nElements, void *p) {
4055  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<wchar_t,unsigned long>[nElements] : new ::unary_function<wchar_t,unsigned long>[nElements];
4056  }
4057  // Wrapper around operator delete
4058  static void delete_unary_functionlEwchar_tcOunsignedsPlonggR(void *p) {
4059  delete ((::unary_function<wchar_t,unsigned long>*)p);
4060  }
4061  static void deleteArray_unary_functionlEwchar_tcOunsignedsPlonggR(void *p) {
4062  delete [] ((::unary_function<wchar_t,unsigned long>*)p);
4063  }
4064  static void destruct_unary_functionlEwchar_tcOunsignedsPlonggR(void *p) {
4065  typedef ::unary_function<wchar_t,unsigned long> current_t;
4066  ((current_t*)p)->~current_t();
4067  }
4068 } // end of namespace ROOT for class ::unary_function<wchar_t,unsigned long>
4069 
4070 namespace ROOT {
4071  // Wrappers around operator new
4072  static void *new_unary_functionlEchar16_tcOunsignedsPlonggR(void *p) {
4073  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<char16_t,unsigned long> : new ::unary_function<char16_t,unsigned long>;
4074  }
4075  static void *newArray_unary_functionlEchar16_tcOunsignedsPlonggR(Long_t nElements, void *p) {
4076  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<char16_t,unsigned long>[nElements] : new ::unary_function<char16_t,unsigned long>[nElements];
4077  }
4078  // Wrapper around operator delete
4079  static void delete_unary_functionlEchar16_tcOunsignedsPlonggR(void *p) {
4080  delete ((::unary_function<char16_t,unsigned long>*)p);
4081  }
4082  static void deleteArray_unary_functionlEchar16_tcOunsignedsPlonggR(void *p) {
4083  delete [] ((::unary_function<char16_t,unsigned long>*)p);
4084  }
4085  static void destruct_unary_functionlEchar16_tcOunsignedsPlonggR(void *p) {
4086  typedef ::unary_function<char16_t,unsigned long> current_t;
4087  ((current_t*)p)->~current_t();
4088  }
4089 } // end of namespace ROOT for class ::unary_function<char16_t,unsigned long>
4090 
4091 namespace ROOT {
4092  // Wrappers around operator new
4093  static void *new_unary_functionlEchar32_tcOunsignedsPlonggR(void *p) {
4094  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<char32_t,unsigned long> : new ::unary_function<char32_t,unsigned long>;
4095  }
4096  static void *newArray_unary_functionlEchar32_tcOunsignedsPlonggR(Long_t nElements, void *p) {
4097  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<char32_t,unsigned long>[nElements] : new ::unary_function<char32_t,unsigned long>[nElements];
4098  }
4099  // Wrapper around operator delete
4100  static void delete_unary_functionlEchar32_tcOunsignedsPlonggR(void *p) {
4101  delete ((::unary_function<char32_t,unsigned long>*)p);
4102  }
4103  static void deleteArray_unary_functionlEchar32_tcOunsignedsPlonggR(void *p) {
4104  delete [] ((::unary_function<char32_t,unsigned long>*)p);
4105  }
4106  static void destruct_unary_functionlEchar32_tcOunsignedsPlonggR(void *p) {
4107  typedef ::unary_function<char32_t,unsigned long> current_t;
4108  ((current_t*)p)->~current_t();
4109  }
4110 } // end of namespace ROOT for class ::unary_function<char32_t,unsigned long>
4111 
4112 namespace ROOT {
4113  // Wrappers around operator new
4114  static void *new_unary_functionlEshortcOunsignedsPlonggR(void *p) {
4115  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<short,unsigned long> : new ::unary_function<short,unsigned long>;
4116  }
4117  static void *newArray_unary_functionlEshortcOunsignedsPlonggR(Long_t nElements, void *p) {
4118  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<short,unsigned long>[nElements] : new ::unary_function<short,unsigned long>[nElements];
4119  }
4120  // Wrapper around operator delete
4121  static void delete_unary_functionlEshortcOunsignedsPlonggR(void *p) {
4122  delete ((::unary_function<short,unsigned long>*)p);
4123  }
4124  static void deleteArray_unary_functionlEshortcOunsignedsPlonggR(void *p) {
4125  delete [] ((::unary_function<short,unsigned long>*)p);
4126  }
4127  static void destruct_unary_functionlEshortcOunsignedsPlonggR(void *p) {
4128  typedef ::unary_function<short,unsigned long> current_t;
4129  ((current_t*)p)->~current_t();
4130  }
4131 } // end of namespace ROOT for class ::unary_function<short,unsigned long>
4132 
4133 namespace ROOT {
4134  // Wrappers around operator new
4135  static void *new_unary_functionlEunsignedsPshortcOunsignedsPlonggR(void *p) {
4136  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<unsigned short,unsigned long> : new ::unary_function<unsigned short,unsigned long>;
4137  }
4138  static void *newArray_unary_functionlEunsignedsPshortcOunsignedsPlonggR(Long_t nElements, void *p) {
4139  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<unsigned short,unsigned long>[nElements] : new ::unary_function<unsigned short,unsigned long>[nElements];
4140  }
4141  // Wrapper around operator delete
4142  static void delete_unary_functionlEunsignedsPshortcOunsignedsPlonggR(void *p) {
4143  delete ((::unary_function<unsigned short,unsigned long>*)p);
4144  }
4145  static void deleteArray_unary_functionlEunsignedsPshortcOunsignedsPlonggR(void *p) {
4146  delete [] ((::unary_function<unsigned short,unsigned long>*)p);
4147  }
4148  static void destruct_unary_functionlEunsignedsPshortcOunsignedsPlonggR(void *p) {
4149  typedef ::unary_function<unsigned short,unsigned long> current_t;
4150  ((current_t*)p)->~current_t();
4151  }
4152 } // end of namespace ROOT for class ::unary_function<unsigned short,unsigned long>
4153 
4154 namespace ROOT {
4155  // Wrappers around operator new
4156  static void *new_unary_functionlEintcOunsignedsPlonggR(void *p) {
4157  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<int,unsigned long> : new ::unary_function<int,unsigned long>;
4158  }
4159  static void *newArray_unary_functionlEintcOunsignedsPlonggR(Long_t nElements, void *p) {
4160  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<int,unsigned long>[nElements] : new ::unary_function<int,unsigned long>[nElements];
4161  }
4162  // Wrapper around operator delete
4163  static void delete_unary_functionlEintcOunsignedsPlonggR(void *p) {
4164  delete ((::unary_function<int,unsigned long>*)p);
4165  }
4166  static void deleteArray_unary_functionlEintcOunsignedsPlonggR(void *p) {
4167  delete [] ((::unary_function<int,unsigned long>*)p);
4168  }
4169  static void destruct_unary_functionlEintcOunsignedsPlonggR(void *p) {
4170  typedef ::unary_function<int,unsigned long> current_t;
4171  ((current_t*)p)->~current_t();
4172  }
4173 } // end of namespace ROOT for class ::unary_function<int,unsigned long>
4174 
4175 namespace ROOT {
4176  // Wrappers around operator new
4177  static void *new_unary_functionlEunsignedsPintcOunsignedsPlonggR(void *p) {
4178  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<unsigned int,unsigned long> : new ::unary_function<unsigned int,unsigned long>;
4179  }
4180  static void *newArray_unary_functionlEunsignedsPintcOunsignedsPlonggR(Long_t nElements, void *p) {
4181  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<unsigned int,unsigned long>[nElements] : new ::unary_function<unsigned int,unsigned long>[nElements];
4182  }
4183  // Wrapper around operator delete
4184  static void delete_unary_functionlEunsignedsPintcOunsignedsPlonggR(void *p) {
4185  delete ((::unary_function<unsigned int,unsigned long>*)p);
4186  }
4187  static void deleteArray_unary_functionlEunsignedsPintcOunsignedsPlonggR(void *p) {
4188  delete [] ((::unary_function<unsigned int,unsigned long>*)p);
4189  }
4190  static void destruct_unary_functionlEunsignedsPintcOunsignedsPlonggR(void *p) {
4191  typedef ::unary_function<unsigned int,unsigned long> current_t;
4192  ((current_t*)p)->~current_t();
4193  }
4194 } // end of namespace ROOT for class ::unary_function<unsigned int,unsigned long>
4195 
4196 namespace ROOT {
4197  // Wrappers around operator new
4198  static void *new_unary_functionlElongcOunsignedsPlonggR(void *p) {
4199  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<long,unsigned long> : new ::unary_function<long,unsigned long>;
4200  }
4201  static void *newArray_unary_functionlElongcOunsignedsPlonggR(Long_t nElements, void *p) {
4202  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<long,unsigned long>[nElements] : new ::unary_function<long,unsigned long>[nElements];
4203  }
4204  // Wrapper around operator delete
4205  static void delete_unary_functionlElongcOunsignedsPlonggR(void *p) {
4206  delete ((::unary_function<long,unsigned long>*)p);
4207  }
4208  static void deleteArray_unary_functionlElongcOunsignedsPlonggR(void *p) {
4209  delete [] ((::unary_function<long,unsigned long>*)p);
4210  }
4211  static void destruct_unary_functionlElongcOunsignedsPlonggR(void *p) {
4212  typedef ::unary_function<long,unsigned long> current_t;
4213  ((current_t*)p)->~current_t();
4214  }
4215 } // end of namespace ROOT for class ::unary_function<long,unsigned long>
4216 
4217 namespace ROOT {
4218  // Wrappers around operator new
4219  static void *new_unary_functionlEunsignedsPlongcOunsignedsPlonggR(void *p) {
4220  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<unsigned long,unsigned long> : new ::unary_function<unsigned long,unsigned long>;
4221  }
4222  static void *newArray_unary_functionlEunsignedsPlongcOunsignedsPlonggR(Long_t nElements, void *p) {
4223  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<unsigned long,unsigned long>[nElements] : new ::unary_function<unsigned long,unsigned long>[nElements];
4224  }
4225  // Wrapper around operator delete
4226  static void delete_unary_functionlEunsignedsPlongcOunsignedsPlonggR(void *p) {
4227  delete ((::unary_function<unsigned long,unsigned long>*)p);
4228  }
4229  static void deleteArray_unary_functionlEunsignedsPlongcOunsignedsPlonggR(void *p) {
4230  delete [] ((::unary_function<unsigned long,unsigned long>*)p);
4231  }
4232  static void destruct_unary_functionlEunsignedsPlongcOunsignedsPlonggR(void *p) {
4233  typedef ::unary_function<unsigned long,unsigned long> current_t;
4234  ((current_t*)p)->~current_t();
4235  }
4236 } // end of namespace ROOT for class ::unary_function<unsigned long,unsigned long>
4237 
4238 namespace ROOT {
4239  // Wrappers around operator new
4240  static void *new_unary_functionlEfloatcOunsignedsPlonggR(void *p) {
4241  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<float,unsigned long> : new ::unary_function<float,unsigned long>;
4242  }
4243  static void *newArray_unary_functionlEfloatcOunsignedsPlonggR(Long_t nElements, void *p) {
4244  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<float,unsigned long>[nElements] : new ::unary_function<float,unsigned long>[nElements];
4245  }
4246  // Wrapper around operator delete
4247  static void delete_unary_functionlEfloatcOunsignedsPlonggR(void *p) {
4248  delete ((::unary_function<float,unsigned long>*)p);
4249  }
4250  static void deleteArray_unary_functionlEfloatcOunsignedsPlonggR(void *p) {
4251  delete [] ((::unary_function<float,unsigned long>*)p);
4252  }
4253  static void destruct_unary_functionlEfloatcOunsignedsPlonggR(void *p) {
4254  typedef ::unary_function<float,unsigned long> current_t;
4255  ((current_t*)p)->~current_t();
4256  }
4257 } // end of namespace ROOT for class ::unary_function<float,unsigned long>
4258 
4259 namespace ROOT {
4260  // Wrappers around operator new
4261  static void *new_unary_functionlEdoublecOunsignedsPlonggR(void *p) {
4262  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<double,unsigned long> : new ::unary_function<double,unsigned long>;
4263  }
4264  static void *newArray_unary_functionlEdoublecOunsignedsPlonggR(Long_t nElements, void *p) {
4265  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<double,unsigned long>[nElements] : new ::unary_function<double,unsigned long>[nElements];
4266  }
4267  // Wrapper around operator delete
4268  static void delete_unary_functionlEdoublecOunsignedsPlonggR(void *p) {
4269  delete ((::unary_function<double,unsigned long>*)p);
4270  }
4271  static void deleteArray_unary_functionlEdoublecOunsignedsPlonggR(void *p) {
4272  delete [] ((::unary_function<double,unsigned long>*)p);
4273  }
4274  static void destruct_unary_functionlEdoublecOunsignedsPlonggR(void *p) {
4275  typedef ::unary_function<double,unsigned long> current_t;
4276  ((current_t*)p)->~current_t();
4277  }
4278 } // end of namespace ROOT for class ::unary_function<double,unsigned long>
4279 
4280 namespace ROOT {
4281  // Wrappers around operator new
4282  static void *new_unary_functionlElongsPdoublecOunsignedsPlonggR(void *p) {
4283  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<long double,unsigned long> : new ::unary_function<long double,unsigned long>;
4284  }
4285  static void *newArray_unary_functionlElongsPdoublecOunsignedsPlonggR(Long_t nElements, void *p) {
4286  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<long double,unsigned long>[nElements] : new ::unary_function<long double,unsigned long>[nElements];
4287  }
4288  // Wrapper around operator delete
4289  static void delete_unary_functionlElongsPdoublecOunsignedsPlonggR(void *p) {
4290  delete ((::unary_function<long double,unsigned long>*)p);
4291  }
4292  static void deleteArray_unary_functionlElongsPdoublecOunsignedsPlonggR(void *p) {
4293  delete [] ((::unary_function<long double,unsigned long>*)p);
4294  }
4295  static void destruct_unary_functionlElongsPdoublecOunsignedsPlonggR(void *p) {
4296  typedef ::unary_function<long double,unsigned long> current_t;
4297  ((current_t*)p)->~current_t();
4298  }
4299 } // end of namespace ROOT for class ::unary_function<long double,unsigned long>
4300 
4301 namespace ROOT {
4302  // Wrappers around operator new
4303  static void *new_unary_functionlEstringcOunsignedsPlonggR(void *p) {
4304  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<string,unsigned long> : new ::unary_function<string,unsigned long>;
4305  }
4306  static void *newArray_unary_functionlEstringcOunsignedsPlonggR(Long_t nElements, void *p) {
4307  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<string,unsigned long>[nElements] : new ::unary_function<string,unsigned long>[nElements];
4308  }
4309  // Wrapper around operator delete
4310  static void delete_unary_functionlEstringcOunsignedsPlonggR(void *p) {
4311  delete ((::unary_function<string,unsigned long>*)p);
4312  }
4313  static void deleteArray_unary_functionlEstringcOunsignedsPlonggR(void *p) {
4314  delete [] ((::unary_function<string,unsigned long>*)p);
4315  }
4316  static void destruct_unary_functionlEstringcOunsignedsPlonggR(void *p) {
4317  typedef ::unary_function<string,unsigned long> current_t;
4318  ((current_t*)p)->~current_t();
4319  }
4320 } // end of namespace ROOT for class ::unary_function<string,unsigned long>
4321 
4322 namespace ROOT {
4323  // Wrappers around operator new
4324  static void *new_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR(void *p) {
4325  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long> : new ::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>;
4326  }
4327  static void *newArray_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR(Long_t nElements, void *p) {
4328  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>[nElements] : new ::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>[nElements];
4329  }
4330  // Wrapper around operator delete
4331  static void delete_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR(void *p) {
4332  delete ((::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>*)p);
4333  }
4334  static void deleteArray_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR(void *p) {
4335  delete [] ((::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>*)p);
4336  }
4337  static void destruct_unary_functionlEbasic_stringlEwchar_tcOchar_traitslEwchar_tgRcOallocatorlEwchar_tgRsPgRcOunsignedsPlonggR(void *p) {
4338  typedef ::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long> current_t;
4339  ((current_t*)p)->~current_t();
4340  }
4341 } // end of namespace ROOT for class ::unary_function<basic_string<wchar_t,char_traits<wchar_t>,allocator<wchar_t> >,unsigned long>
4342 
4343 namespace ROOT {
4344  // Wrappers around operator new
4345  static void *new_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR(void *p) {
4346  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long> : new ::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>;
4347  }
4348  static void *newArray_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR(Long_t nElements, void *p) {
4349  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>[nElements] : new ::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>[nElements];
4350  }
4351  // Wrapper around operator delete
4352  static void delete_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR(void *p) {
4353  delete ((::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>*)p);
4354  }
4355  static void deleteArray_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR(void *p) {
4356  delete [] ((::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>*)p);
4357  }
4358  static void destruct_unary_functionlEbasic_stringlEchar16_tcOchar_traitslEchar16_tgRcOallocatorlEchar16_tgRsPgRcOunsignedsPlonggR(void *p) {
4359  typedef ::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long> current_t;
4360  ((current_t*)p)->~current_t();
4361  }
4362 } // end of namespace ROOT for class ::unary_function<basic_string<char16_t,char_traits<char16_t>,allocator<char16_t> >,unsigned long>
4363 
4364 namespace ROOT {
4365  // Wrappers around operator new
4366  static void *new_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR(void *p) {
4367  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long> : new ::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>;
4368  }
4369  static void *newArray_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR(Long_t nElements, void *p) {
4370  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>[nElements] : new ::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>[nElements];
4371  }
4372  // Wrapper around operator delete
4373  static void delete_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR(void *p) {
4374  delete ((::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>*)p);
4375  }
4376  static void deleteArray_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR(void *p) {
4377  delete [] ((::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>*)p);
4378  }
4379  static void destruct_unary_functionlEbasic_stringlEchar32_tcOchar_traitslEchar32_tgRcOallocatorlEchar32_tgRsPgRcOunsignedsPlonggR(void *p) {
4380  typedef ::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long> current_t;
4381  ((current_t*)p)->~current_t();
4382  }
4383 } // end of namespace ROOT for class ::unary_function<basic_string<char32_t,char_traits<char32_t>,allocator<char32_t> >,unsigned long>
4384 
4385 namespace ROOT {
4386  // Wrappers around operator new
4387  static void *new_unary_functionlELong64_tcOunsignedsPlonggR(void *p) {
4388  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<Long64_t,unsigned long> : new ::unary_function<Long64_t,unsigned long>;
4389  }
4390  static void *newArray_unary_functionlELong64_tcOunsignedsPlonggR(Long_t nElements, void *p) {
4391  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<Long64_t,unsigned long>[nElements] : new ::unary_function<Long64_t,unsigned long>[nElements];
4392  }
4393  // Wrapper around operator delete
4394  static void delete_unary_functionlELong64_tcOunsignedsPlonggR(void *p) {
4395  delete ((::unary_function<Long64_t,unsigned long>*)p);
4396  }
4397  static void deleteArray_unary_functionlELong64_tcOunsignedsPlonggR(void *p) {
4398  delete [] ((::unary_function<Long64_t,unsigned long>*)p);
4399  }
4400  static void destruct_unary_functionlELong64_tcOunsignedsPlonggR(void *p) {
4401  typedef ::unary_function<Long64_t,unsigned long> current_t;
4402  ((current_t*)p)->~current_t();
4403  }
4404 } // end of namespace ROOT for class ::unary_function<Long64_t,unsigned long>
4405 
4406 namespace ROOT {
4407  // Wrappers around operator new
4408  static void *new_unary_functionlEULong64_tcOunsignedsPlonggR(void *p) {
4409  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<ULong64_t,unsigned long> : new ::unary_function<ULong64_t,unsigned long>;
4410  }
4411  static void *newArray_unary_functionlEULong64_tcOunsignedsPlonggR(Long_t nElements, void *p) {
4412  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<ULong64_t,unsigned long>[nElements] : new ::unary_function<ULong64_t,unsigned long>[nElements];
4413  }
4414  // Wrapper around operator delete
4415  static void delete_unary_functionlEULong64_tcOunsignedsPlonggR(void *p) {
4416  delete ((::unary_function<ULong64_t,unsigned long>*)p);
4417  }
4418  static void deleteArray_unary_functionlEULong64_tcOunsignedsPlonggR(void *p) {
4419  delete [] ((::unary_function<ULong64_t,unsigned long>*)p);
4420  }
4421  static void destruct_unary_functionlEULong64_tcOunsignedsPlonggR(void *p) {
4422  typedef ::unary_function<ULong64_t,unsigned long> current_t;
4423  ((current_t*)p)->~current_t();
4424  }
4425 } // end of namespace ROOT for class ::unary_function<ULong64_t,unsigned long>
4426 
4427 namespace ROOT {
4428  // Wrappers around operator new
4429  static void *new_unary_functionlEtype_indexcOunsignedsPlonggR(void *p) {
4430  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<type_index,unsigned long> : new ::unary_function<type_index,unsigned long>;
4431  }
4432  static void *newArray_unary_functionlEtype_indexcOunsignedsPlonggR(Long_t nElements, void *p) {
4433  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<type_index,unsigned long>[nElements] : new ::unary_function<type_index,unsigned long>[nElements];
4434  }
4435  // Wrapper around operator delete
4436  static void delete_unary_functionlEtype_indexcOunsignedsPlonggR(void *p) {
4437  delete ((::unary_function<type_index,unsigned long>*)p);
4438  }
4439  static void deleteArray_unary_functionlEtype_indexcOunsignedsPlonggR(void *p) {
4440  delete [] ((::unary_function<type_index,unsigned long>*)p);
4441  }
4442  static void destruct_unary_functionlEtype_indexcOunsignedsPlonggR(void *p) {
4443  typedef ::unary_function<type_index,unsigned long> current_t;
4444  ((current_t*)p)->~current_t();
4445  }
4446 } // end of namespace ROOT for class ::unary_function<type_index,unsigned long>
4447 
4448 namespace ROOT {
4449  // Wrappers around operator new
4450  static void *new_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR(void *p) {
4451  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<Gaudi::Details::PropertyBase&,void> : new ::unary_function<Gaudi::Details::PropertyBase&,void>;
4452  }
4453  static void *newArray_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR(Long_t nElements, void *p) {
4454  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<Gaudi::Details::PropertyBase&,void>[nElements] : new ::unary_function<Gaudi::Details::PropertyBase&,void>[nElements];
4455  }
4456  // Wrapper around operator delete
4457  static void delete_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR(void *p) {
4458  delete ((::unary_function<Gaudi::Details::PropertyBase&,void>*)p);
4459  }
4460  static void deleteArray_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR(void *p) {
4461  delete [] ((::unary_function<Gaudi::Details::PropertyBase&,void>*)p);
4462  }
4463  static void destruct_unary_functionlEGaudicLcLDetailscLcLPropertyBaseaNcOvoidgR(void *p) {
4464  typedef ::unary_function<Gaudi::Details::PropertyBase&,void> current_t;
4465  ((current_t*)p)->~current_t();
4466  }
4467 } // end of namespace ROOT for class ::unary_function<Gaudi::Details::PropertyBase&,void>
4468 
4469 namespace ROOT {
4470  // Wrappers around operator new
4471  static void *new_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR(void *p) {
4472  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<const IInterface*,IInterface*> : new ::unary_function<const IInterface*,IInterface*>;
4473  }
4474  static void *newArray_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR(Long_t nElements, void *p) {
4475  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<const IInterface*,IInterface*>[nElements] : new ::unary_function<const IInterface*,IInterface*>[nElements];
4476  }
4477  // Wrapper around operator delete
4478  static void delete_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR(void *p) {
4479  delete ((::unary_function<const IInterface*,IInterface*>*)p);
4480  }
4481  static void deleteArray_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR(void *p) {
4482  delete [] ((::unary_function<const IInterface*,IInterface*>*)p);
4483  }
4484  static void destruct_unary_functionlEconstsPIInterfacemUcOIInterfacemUgR(void *p) {
4485  typedef ::unary_function<const IInterface*,IInterface*> current_t;
4486  ((current_t*)p)->~current_t();
4487  }
4488 } // end of namespace ROOT for class ::unary_function<const IInterface*,IInterface*>
4489 
4490 namespace ROOT {
4491  // Wrappers around operator new
4492  static void *new_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR(void *p) {
4493  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<pair<const string,string>,const string> : new ::unary_function<pair<const string,string>,const string>;
4494  }
4495  static void *newArray_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR(Long_t nElements, void *p) {
4496  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::unary_function<pair<const string,string>,const string>[nElements] : new ::unary_function<pair<const string,string>,const string>[nElements];
4497  }
4498  // Wrapper around operator delete
4499  static void delete_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR(void *p) {
4500  delete ((::unary_function<pair<const string,string>,const string>*)p);
4501  }
4502  static void deleteArray_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR(void *p) {
4503  delete [] ((::unary_function<pair<const string,string>,const string>*)p);
4504  }
4505  static void destruct_unary_functionlEpairlEconstsPstringcOstringgRcOconstsPstringgR(void *p) {
4506  typedef ::unary_function<pair<const string,string>,const string> current_t;
4507  ((current_t*)p)->~current_t();
4508  }
4509 } // end of namespace ROOT for class ::unary_function<pair<const string,string>,const string>
4510 
4511 namespace ROOT {
4512  // Wrappers around operator new
4513  static void *new__Bit_reference(void *p) {
4514  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::_Bit_reference : new ::_Bit_reference;
4515  }
4516  static void *newArray__Bit_reference(Long_t nElements, void *p) {
4517  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::_Bit_reference[nElements] : new ::_Bit_reference[nElements];
4518  }
4519  // Wrapper around operator delete
4520  static void delete__Bit_reference(void *p) {
4521  delete ((::_Bit_reference*)p);
4522  }
4523  static void deleteArray__Bit_reference(void *p) {
4524  delete [] ((::_Bit_reference*)p);
4525  }
4526  static void destruct__Bit_reference(void *p) {
4527  typedef ::_Bit_reference current_t;
4528  ((current_t*)p)->~current_t();
4529  }
4530 } // end of namespace ROOT for class ::_Bit_reference
4531 
4532 namespace ROOT {
4533  // Wrappers around operator new
4534  static void *new_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p) {
4535  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::basic_stringbuf<char,char_traits<char>,allocator<char> > : new ::basic_stringbuf<char,char_traits<char>,allocator<char> >;
4536  }
4537  static void *newArray_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(Long_t nElements, void *p) {
4538  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::basic_stringbuf<char,char_traits<char>,allocator<char> >[nElements] : new ::basic_stringbuf<char,char_traits<char>,allocator<char> >[nElements];
4539  }
4540  // Wrapper around operator delete
4541  static void delete_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p) {
4542  delete ((::basic_stringbuf<char,char_traits<char>,allocator<char> >*)p);
4543  }
4544  static void deleteArray_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p) {
4545  delete [] ((::basic_stringbuf<char,char_traits<char>,allocator<char> >*)p);
4546  }
4547  static void destruct_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p) {
4548  typedef ::basic_stringbuf<char,char_traits<char>,allocator<char> > current_t;
4549  ((current_t*)p)->~current_t();
4550  }
4551 } // end of namespace ROOT for class ::basic_stringbuf<char,char_traits<char>,allocator<char> >
4552 
4553 namespace ROOT {
4554  // Wrappers around operator new
4555  static void *new_GaudicLcLUtilscLcLMapBase(void *p) {
4556  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::MapBase : new ::Gaudi::Utils::MapBase;
4557  }
4558  static void *newArray_GaudicLcLUtilscLcLMapBase(Long_t nElements, void *p) {
4559  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::MapBase[nElements] : new ::Gaudi::Utils::MapBase[nElements];
4560  }
4561  // Wrapper around operator delete
4562  static void delete_GaudicLcLUtilscLcLMapBase(void *p) {
4563  delete ((::Gaudi::Utils::MapBase*)p);
4564  }
4565  static void deleteArray_GaudicLcLUtilscLcLMapBase(void *p) {
4566  delete [] ((::Gaudi::Utils::MapBase*)p);
4567  }
4568  static void destruct_GaudicLcLUtilscLcLMapBase(void *p) {
4569  typedef ::Gaudi::Utils::MapBase current_t;
4570  ((current_t*)p)->~current_t();
4571  }
4572 } // end of namespace ROOT for class ::Gaudi::Utils::MapBase
4573 
4574 namespace ROOT {
4575  // Wrappers around operator new
4576  static void *new_GaudicLcLStringKey(void *p) {
4577  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::StringKey : new ::Gaudi::StringKey;
4578  }
4579  static void *newArray_GaudicLcLStringKey(Long_t nElements, void *p) {
4580  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::StringKey[nElements] : new ::Gaudi::StringKey[nElements];
4581  }
4582  // Wrapper around operator delete
4583  static void delete_GaudicLcLStringKey(void *p) {
4584  delete ((::Gaudi::StringKey*)p);
4585  }
4586  static void deleteArray_GaudicLcLStringKey(void *p) {
4587  delete [] ((::Gaudi::StringKey*)p);
4588  }
4589  static void destruct_GaudicLcLStringKey(void *p) {
4590  typedef ::Gaudi::StringKey current_t;
4591  ((current_t*)p)->~current_t();
4592  }
4593 } // end of namespace ROOT for class ::Gaudi::StringKey
4594 
4595 namespace ROOT {
4596  // Wrappers around operator new
4597  static void *new_StatEntity(void *p) {
4598  return p ? new(p) ::StatEntity : new ::StatEntity;
4599  }
4600  static void *newArray_StatEntity(Long_t nElements, void *p) {
4601  return p ? new(p) ::StatEntity[nElements] : new ::StatEntity[nElements];
4602  }
4603  // Wrapper around operator delete
4604  static void delete_StatEntity(void *p) {
4605  delete ((::StatEntity*)p);
4606  }
4607  static void deleteArray_StatEntity(void *p) {
4608  delete [] ((::StatEntity*)p);
4609  }
4610  static void destruct_StatEntity(void *p) {
4611  typedef ::StatEntity current_t;
4612  ((current_t*)p)->~current_t();
4613  }
4614 } // end of namespace ROOT for class ::StatEntity
4615 
4616 namespace ROOT {
4617  // Wrappers around operator new
4618  static void *new_ChronoEntity(void *p) {
4619  return p ? new(p) ::ChronoEntity : new ::ChronoEntity;
4620  }
4621  static void *newArray_ChronoEntity(Long_t nElements, void *p) {
4622  return p ? new(p) ::ChronoEntity[nElements] : new ::ChronoEntity[nElements];
4623  }
4624  // Wrapper around operator delete
4625  static void delete_ChronoEntity(void *p) {
4626  delete ((::ChronoEntity*)p);
4627  }
4628  static void deleteArray_ChronoEntity(void *p) {
4629  delete [] ((::ChronoEntity*)p);
4630  }
4631  static void destruct_ChronoEntity(void *p) {
4632  typedef ::ChronoEntity current_t;
4633  ((current_t*)p)->~current_t();
4634  }
4635 } // end of namespace ROOT for class ::ChronoEntity
4636 
4637 namespace ROOT {
4638  // Wrappers around operator new
4639  static void *new_Chrono(void *p) {
4640  return p ? new(p) ::Chrono : new ::Chrono;
4641  }
4642  static void *newArray_Chrono(Long_t nElements, void *p) {
4643  return p ? new(p) ::Chrono[nElements] : new ::Chrono[nElements];
4644  }
4645  // Wrapper around operator delete
4646  static void delete_Chrono(void *p) {
4647  delete ((::Chrono*)p);
4648  }
4649  static void deleteArray_Chrono(void *p) {
4650  delete [] ((::Chrono*)p);
4651  }
4652  static void destruct_Chrono(void *p) {
4653  typedef ::Chrono current_t;
4654  ((current_t*)p)->~current_t();
4655  }
4656 } // end of namespace ROOT for class ::Chrono
4657 
4658 namespace ROOT {
4659  // Wrappers around operator new
4660  static void *new_ParticleProperty(void *p) {
4661  return p ? new(p) ::ParticleProperty : new ::ParticleProperty;
4662  }
4663  static void *newArray_ParticleProperty(Long_t nElements, void *p) {
4664  return p ? new(p) ::ParticleProperty[nElements] : new ::ParticleProperty[nElements];
4665  }
4666  // Wrapper around operator delete
4667  static void delete_ParticleProperty(void *p) {
4668  delete ((::ParticleProperty*)p);
4669  }
4670  static void deleteArray_ParticleProperty(void *p) {
4671  delete [] ((::ParticleProperty*)p);
4672  }
4673  static void destruct_ParticleProperty(void *p) {
4674  typedef ::ParticleProperty current_t;
4675  ((current_t*)p)->~current_t();
4676  }
4677 } // end of namespace ROOT for class ::ParticleProperty
4678 
4679 namespace ROOT {
4680  // Wrappers around operator new
4681  static void *new_GaudicLcLRangeBase_(void *p) {
4682  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::RangeBase_ : new ::Gaudi::RangeBase_;
4683  }
4684  static void *newArray_GaudicLcLRangeBase_(Long_t nElements, void *p) {
4685  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::RangeBase_[nElements] : new ::Gaudi::RangeBase_[nElements];
4686  }
4687  // Wrapper around operator delete
4688  static void delete_GaudicLcLRangeBase_(void *p) {
4689  delete ((::Gaudi::RangeBase_*)p);
4690  }
4691  static void deleteArray_GaudicLcLRangeBase_(void *p) {
4692  delete [] ((::Gaudi::RangeBase_*)p);
4693  }
4694  static void destruct_GaudicLcLRangeBase_(void *p) {
4695  typedef ::Gaudi::RangeBase_ current_t;
4696  ((current_t*)p)->~current_t();
4697  }
4698 } // end of namespace ROOT for class ::Gaudi::RangeBase_
4699 
4700 namespace ROOT {
4701  // Wrappers around operator new
4702  static void *new_Stat(void *p) {
4703  return p ? new(p) ::Stat : new ::Stat;
4704  }
4705  static void *newArray_Stat(Long_t nElements, void *p) {
4706  return p ? new(p) ::Stat[nElements] : new ::Stat[nElements];
4707  }
4708  // Wrapper around operator delete
4709  static void delete_Stat(void *p) {
4710  delete ((::Stat*)p);
4711  }
4712  static void deleteArray_Stat(void *p) {
4713  delete [] ((::Stat*)p);
4714  }
4715  static void destruct_Stat(void *p) {
4716  typedef ::Stat current_t;
4717  ((current_t*)p)->~current_t();
4718  }
4719 } // end of namespace ROOT for class ::Stat
4720 
4721 namespace ROOT {
4722  // Wrapper around operator delete
4723  static void delete_AIDAcLcLIAxis(void *p) {
4724  delete ((::AIDA::IAxis*)p);
4725  }
4726  static void deleteArray_AIDAcLcLIAxis(void *p) {
4727  delete [] ((::AIDA::IAxis*)p);
4728  }
4729  static void destruct_AIDAcLcLIAxis(void *p) {
4730  typedef ::AIDA::IAxis current_t;
4731  ((current_t*)p)->~current_t();
4732  }
4733 } // end of namespace ROOT for class ::AIDA::IAxis
4734 
4735 namespace ROOT {
4736  // Wrapper around operator delete
4737  static void delete_AIDAcLcLIBaseHistogram(void *p) {
4738  delete ((::AIDA::IBaseHistogram*)p);
4739  }
4740  static void deleteArray_AIDAcLcLIBaseHistogram(void *p) {
4741  delete [] ((::AIDA::IBaseHistogram*)p);
4742  }
4743  static void destruct_AIDAcLcLIBaseHistogram(void *p) {
4744  typedef ::AIDA::IBaseHistogram current_t;
4745  ((current_t*)p)->~current_t();
4746  }
4747 } // end of namespace ROOT for class ::AIDA::IBaseHistogram
4748 
4749 namespace ROOT {
4750  // Wrapper around operator delete
4751  static void delete_AIDAcLcLIHistogram(void *p) {
4752  delete ((::AIDA::IHistogram*)p);
4753  }
4754  static void deleteArray_AIDAcLcLIHistogram(void *p) {
4755  delete [] ((::AIDA::IHistogram*)p);
4756  }
4757  static void destruct_AIDAcLcLIHistogram(void *p) {
4758  typedef ::AIDA::IHistogram current_t;
4759  ((current_t*)p)->~current_t();
4760  }
4761 } // end of namespace ROOT for class ::AIDA::IHistogram
4762 
4763 namespace ROOT {
4764  // Wrapper around operator delete
4765  static void delete_AIDAcLcLIHistogram1D(void *p) {
4766  delete ((::AIDA::IHistogram1D*)p);
4767  }
4768  static void deleteArray_AIDAcLcLIHistogram1D(void *p) {
4769  delete [] ((::AIDA::IHistogram1D*)p);
4770  }
4771  static void destruct_AIDAcLcLIHistogram1D(void *p) {
4772  typedef ::AIDA::IHistogram1D current_t;
4773  ((current_t*)p)->~current_t();
4774  }
4775 } // end of namespace ROOT for class ::AIDA::IHistogram1D
4776 
4777 namespace ROOT {
4778  // Wrapper around operator delete
4779  static void delete_AIDAcLcLIHistogram2D(void *p) {
4780  delete ((::AIDA::IHistogram2D*)p);
4781  }
4782  static void deleteArray_AIDAcLcLIHistogram2D(void *p) {
4783  delete [] ((::AIDA::IHistogram2D*)p);
4784  }
4785  static void destruct_AIDAcLcLIHistogram2D(void *p) {
4786  typedef ::AIDA::IHistogram2D current_t;
4787  ((current_t*)p)->~current_t();
4788  }
4789 } // end of namespace ROOT for class ::AIDA::IHistogram2D
4790 
4791 namespace ROOT {
4792  // Wrapper around operator delete
4793  static void delete_AIDAcLcLIHistogram3D(void *p) {
4794  delete ((::AIDA::IHistogram3D*)p);
4795  }
4796  static void deleteArray_AIDAcLcLIHistogram3D(void *p) {
4797  delete [] ((::AIDA::IHistogram3D*)p);
4798  }
4799  static void destruct_AIDAcLcLIHistogram3D(void *p) {
4800  typedef ::AIDA::IHistogram3D current_t;
4801  ((current_t*)p)->~current_t();
4802  }
4803 } // end of namespace ROOT for class ::AIDA::IHistogram3D
4804 
4805 namespace ROOT {
4806  // Wrapper around operator delete
4807  static void delete_AIDAcLcLIProfile(void *p) {
4808  delete ((::AIDA::IProfile*)p);
4809  }
4810  static void deleteArray_AIDAcLcLIProfile(void *p) {
4811  delete [] ((::AIDA::IProfile*)p);
4812  }
4813  static void destruct_AIDAcLcLIProfile(void *p) {
4814  typedef ::AIDA::IProfile current_t;
4815  ((current_t*)p)->~current_t();
4816  }
4817 } // end of namespace ROOT for class ::AIDA::IProfile
4818 
4819 namespace ROOT {
4820  // Wrapper around operator delete
4821  static void delete_AIDAcLcLIProfile1D(void *p) {
4822  delete ((::AIDA::IProfile1D*)p);
4823  }
4824  static void deleteArray_AIDAcLcLIProfile1D(void *p) {
4825  delete [] ((::AIDA::IProfile1D*)p);
4826  }
4827  static void destruct_AIDAcLcLIProfile1D(void *p) {
4828  typedef ::AIDA::IProfile1D current_t;
4829  ((current_t*)p)->~current_t();
4830  }
4831 } // end of namespace ROOT for class ::AIDA::IProfile1D
4832 
4833 namespace ROOT {
4834  // Wrapper around operator delete
4835  static void delete_AIDAcLcLIProfile2D(void *p) {
4836  delete ((::AIDA::IProfile2D*)p);
4837  }
4838  static void deleteArray_AIDAcLcLIProfile2D(void *p) {
4839  delete [] ((::AIDA::IProfile2D*)p);
4840  }
4841  static void destruct_AIDAcLcLIProfile2D(void *p) {
4842  typedef ::AIDA::IProfile2D current_t;
4843  ((current_t*)p)->~current_t();
4844  }
4845 } // end of namespace ROOT for class ::AIDA::IProfile2D
4846 
4847 namespace ROOT {
4848  // Wrappers around operator new
4849  static void *new_GaudiPythoncLcLHelper(void *p) {
4850  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::Helper : new ::GaudiPython::Helper;
4851  }
4852  static void *newArray_GaudiPythoncLcLHelper(Long_t nElements, void *p) {
4853  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::Helper[nElements] : new ::GaudiPython::Helper[nElements];
4854  }
4855  // Wrapper around operator delete
4856  static void delete_GaudiPythoncLcLHelper(void *p) {
4857  delete ((::GaudiPython::Helper*)p);
4858  }
4859  static void deleteArray_GaudiPythoncLcLHelper(void *p) {
4860  delete [] ((::GaudiPython::Helper*)p);
4861  }
4862  static void destruct_GaudiPythoncLcLHelper(void *p) {
4863  typedef ::GaudiPython::Helper current_t;
4864  ((current_t*)p)->~current_t();
4865  }
4866 } // end of namespace ROOT for class ::GaudiPython::Helper
4867 
4868 namespace ROOT {
4869 } // end of namespace ROOT for class ::GaudiCommon<Algorithm>
4870 
4871 namespace ROOT {
4872 } // end of namespace ROOT for class ::GaudiCommon<AlgTool>
4873 
4874 namespace ROOT {
4875  // Wrapper around operator delete
4876  static void delete_GaudiAlgorithm(void *p) {
4877  delete ((::GaudiAlgorithm*)p);
4878  }
4879  static void deleteArray_GaudiAlgorithm(void *p) {
4880  delete [] ((::GaudiAlgorithm*)p);
4881  }
4882  static void destruct_GaudiAlgorithm(void *p) {
4883  typedef ::GaudiAlgorithm current_t;
4884  ((current_t*)p)->~current_t();
4885  }
4886 } // end of namespace ROOT for class ::GaudiAlgorithm
4887 
4888 namespace ROOT {
4889  // Wrappers around operator new
4890  static void *new_GaudiPythoncLcLAlgDecorator(void *p) {
4891  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::AlgDecorator : new ::GaudiPython::AlgDecorator;
4892  }
4893  static void *newArray_GaudiPythoncLcLAlgDecorator(Long_t nElements, void *p) {
4894  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::AlgDecorator[nElements] : new ::GaudiPython::AlgDecorator[nElements];
4895  }
4896  // Wrapper around operator delete
4897  static void delete_GaudiPythoncLcLAlgDecorator(void *p) {
4898  delete ((::GaudiPython::AlgDecorator*)p);
4899  }
4900  static void deleteArray_GaudiPythoncLcLAlgDecorator(void *p) {
4901  delete [] ((::GaudiPython::AlgDecorator*)p);
4902  }
4903  static void destruct_GaudiPythoncLcLAlgDecorator(void *p) {
4904  typedef ::GaudiPython::AlgDecorator current_t;
4905  ((current_t*)p)->~current_t();
4906  }
4907 } // end of namespace ROOT for class ::GaudiPython::AlgDecorator
4908 
4909 namespace ROOT {
4910  // Wrapper around operator delete
4911  static void delete_GaudiPythoncLcLPyAlgorithm(void *p) {
4912  delete ((::GaudiPython::PyAlgorithm*)p);
4913  }
4914  static void deleteArray_GaudiPythoncLcLPyAlgorithm(void *p) {
4915  delete [] ((::GaudiPython::PyAlgorithm*)p);
4916  }
4917  static void destruct_GaudiPythoncLcLPyAlgorithm(void *p) {
4918  typedef ::GaudiPython::PyAlgorithm current_t;
4919  ((current_t*)p)->~current_t();
4920  }
4921 } // end of namespace ROOT for class ::GaudiPython::PyAlgorithm
4922 
4923 namespace ROOT {
4924 } // end of namespace ROOT for class ::GaudiPython::PyAlg<GaudiAlgorithm>
4925 
4926 namespace ROOT {
4927 } // end of namespace ROOT for class ::GaudiPython::PyAlg<GaudiHistoAlg>
4928 
4929 namespace ROOT {
4930 } // end of namespace ROOT for class ::GaudiPython::PyAlg<GaudiTupleAlg>
4931 
4932 namespace ROOT {
4933  // Wrapper around operator delete
4934  static void delete_GaudiPythoncLcLCallbackStreamBuf(void *p) {
4935  delete ((::GaudiPython::CallbackStreamBuf*)p);
4936  }
4937  static void deleteArray_GaudiPythoncLcLCallbackStreamBuf(void *p) {
4938  delete [] ((::GaudiPython::CallbackStreamBuf*)p);
4939  }
4940  static void destruct_GaudiPythoncLcLCallbackStreamBuf(void *p) {
4941  typedef ::GaudiPython::CallbackStreamBuf current_t;
4942  ((current_t*)p)->~current_t();
4943  }
4944 } // end of namespace ROOT for class ::GaudiPython::CallbackStreamBuf
4945 
4946 namespace ROOT {
4947  // Wrappers around operator new
4948  static void *new_GaudicLcLUtilscLcLHistoscLcLTable(void *p) {
4949  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::Histos::Table : new ::Gaudi::Utils::Histos::Table;
4950  }
4951  static void *newArray_GaudicLcLUtilscLcLHistoscLcLTable(Long_t nElements, void *p) {
4952  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::Histos::Table[nElements] : new ::Gaudi::Utils::Histos::Table[nElements];
4953  }
4954  // Wrapper around operator delete
4955  static void delete_GaudicLcLUtilscLcLHistoscLcLTable(void *p) {
4956  delete ((::Gaudi::Utils::Histos::Table*)p);
4957  }
4958  static void deleteArray_GaudicLcLUtilscLcLHistoscLcLTable(void *p) {
4959  delete [] ((::Gaudi::Utils::Histos::Table*)p);
4960  }
4961  static void destruct_GaudicLcLUtilscLcLHistoscLcLTable(void *p) {
4962  typedef ::Gaudi::Utils::Histos::Table current_t;
4963  ((current_t*)p)->~current_t();
4964  }
4965 } // end of namespace ROOT for class ::Gaudi::Utils::Histos::Table
4966 
4967 namespace ROOT {
4968  // Wrappers around operator new
4969  static void *new_GaudiAlgcLcLID(void *p) {
4970  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::ID : new ::GaudiAlg::ID;
4971  }
4972  static void *newArray_GaudiAlgcLcLID(Long_t nElements, void *p) {
4973  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::ID[nElements] : new ::GaudiAlg::ID[nElements];
4974  }
4975  // Wrapper around operator delete
4976  static void delete_GaudiAlgcLcLID(void *p) {
4977  delete ((::GaudiAlg::ID*)p);
4978  }
4979  static void deleteArray_GaudiAlgcLcLID(void *p) {
4980  delete [] ((::GaudiAlg::ID*)p);
4981  }
4982  static void destruct_GaudiAlgcLcLID(void *p) {
4983  typedef ::GaudiAlg::ID current_t;
4984  ((current_t*)p)->~current_t();
4985  }
4986 } // end of namespace ROOT for class ::GaudiAlg::ID
4987 
4988 namespace ROOT {
4989  // Wrapper around operator delete
4990  static void delete_GaudiHistoslEGaudiAlgorithmgR(void *p) {
4991  delete ((::GaudiHistos<GaudiAlgorithm>*)p);
4992  }
4993  static void deleteArray_GaudiHistoslEGaudiAlgorithmgR(void *p) {
4994  delete [] ((::GaudiHistos<GaudiAlgorithm>*)p);
4995  }
4996  static void destruct_GaudiHistoslEGaudiAlgorithmgR(void *p) {
4997  typedef ::GaudiHistos<GaudiAlgorithm> current_t;
4998  ((current_t*)p)->~current_t();
4999  }
5000 } // end of namespace ROOT for class ::GaudiHistos<GaudiAlgorithm>
5001 
5002 namespace ROOT {
5003  // Wrapper around operator delete
5004  static void delete_GaudiHistoslEGaudiToolgR(void *p) {
5005  delete ((::GaudiHistos<GaudiTool>*)p);
5006  }
5007  static void deleteArray_GaudiHistoslEGaudiToolgR(void *p) {
5008  delete [] ((::GaudiHistos<GaudiTool>*)p);
5009  }
5010  static void destruct_GaudiHistoslEGaudiToolgR(void *p) {
5011  typedef ::GaudiHistos<GaudiTool> current_t;
5012  ((current_t*)p)->~current_t();
5013  }
5014 } // end of namespace ROOT for class ::GaudiHistos<GaudiTool>
5015 
5016 namespace ROOT {
5017  // Wrappers around operator new
5018  static void *new_GaudiPythoncLcLHistoDecorator(void *p) {
5019  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::HistoDecorator : new ::GaudiPython::HistoDecorator;
5020  }
5021  static void *newArray_GaudiPythoncLcLHistoDecorator(Long_t nElements, void *p) {
5022  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::HistoDecorator[nElements] : new ::GaudiPython::HistoDecorator[nElements];
5023  }
5024  // Wrapper around operator delete
5025  static void delete_GaudiPythoncLcLHistoDecorator(void *p) {
5026  delete ((::GaudiPython::HistoDecorator*)p);
5027  }
5028  static void deleteArray_GaudiPythoncLcLHistoDecorator(void *p) {
5029  delete [] ((::GaudiPython::HistoDecorator*)p);
5030  }
5031  static void destruct_GaudiPythoncLcLHistoDecorator(void *p) {
5032  typedef ::GaudiPython::HistoDecorator current_t;
5033  ((current_t*)p)->~current_t();
5034  }
5035 } // end of namespace ROOT for class ::GaudiPython::HistoDecorator
5036 
5037 namespace ROOT {
5038  // Wrappers around operator new
5039  static void *new_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p) {
5040  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::Printer<ContainedObject> : new ::GaudiPython::Printer<ContainedObject>;
5041  }
5042  static void *newArray_GaudiPythoncLcLPrinterlEContainedObjectgR(Long_t nElements, void *p) {
5043  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::Printer<ContainedObject>[nElements] : new ::GaudiPython::Printer<ContainedObject>[nElements];
5044  }
5045  // Wrapper around operator delete
5046  static void delete_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p) {
5047  delete ((::GaudiPython::Printer<ContainedObject>*)p);
5048  }
5049  static void deleteArray_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p) {
5050  delete [] ((::GaudiPython::Printer<ContainedObject>*)p);
5051  }
5052  static void destruct_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p) {
5053  typedef ::GaudiPython::Printer<ContainedObject> current_t;
5054  ((current_t*)p)->~current_t();
5055  }
5056 } // end of namespace ROOT for class ::GaudiPython::Printer<ContainedObject>
5057 
5058 namespace ROOT {
5059  // Wrappers around operator new
5060  static void *new_GaudiPythoncLcLPrinterlEDataObjectgR(void *p) {
5061  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::Printer<DataObject> : new ::GaudiPython::Printer<DataObject>;
5062  }
5063  static void *newArray_GaudiPythoncLcLPrinterlEDataObjectgR(Long_t nElements, void *p) {
5064  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::Printer<DataObject>[nElements] : new ::GaudiPython::Printer<DataObject>[nElements];
5065  }
5066  // Wrapper around operator delete
5067  static void delete_GaudiPythoncLcLPrinterlEDataObjectgR(void *p) {
5068  delete ((::GaudiPython::Printer<DataObject>*)p);
5069  }
5070  static void deleteArray_GaudiPythoncLcLPrinterlEDataObjectgR(void *p) {
5071  delete [] ((::GaudiPython::Printer<DataObject>*)p);
5072  }
5073  static void destruct_GaudiPythoncLcLPrinterlEDataObjectgR(void *p) {
5074  typedef ::GaudiPython::Printer<DataObject> current_t;
5075  ((current_t*)p)->~current_t();
5076  }
5077 } // end of namespace ROOT for class ::GaudiPython::Printer<DataObject>
5078 
5079 namespace ROOT {
5080  // Wrapper around operator delete
5081  static void delete_TuplescLcLTuple(void *p) {
5082  delete ((::Tuples::Tuple*)p);
5083  }
5084  static void deleteArray_TuplescLcLTuple(void *p) {
5085  delete [] ((::Tuples::Tuple*)p);
5086  }
5087  static void destruct_TuplescLcLTuple(void *p) {
5088  typedef ::Tuples::Tuple current_t;
5089  ((current_t*)p)->~current_t();
5090  }
5091 } // end of namespace ROOT for class ::Tuples::Tuple
5092 
5093 namespace ROOT {
5094  // Wrapper around operator delete
5095  static void delete_GaudiTupleslEGaudiHistoAlggR(void *p) {
5096  delete ((::GaudiTuples<GaudiHistoAlg>*)p);
5097  }
5098  static void deleteArray_GaudiTupleslEGaudiHistoAlggR(void *p) {
5099  delete [] ((::GaudiTuples<GaudiHistoAlg>*)p);
5100  }
5101  static void destruct_GaudiTupleslEGaudiHistoAlggR(void *p) {
5102  typedef ::GaudiTuples<GaudiHistoAlg> current_t;
5103  ((current_t*)p)->~current_t();
5104  }
5105 } // end of namespace ROOT for class ::GaudiTuples<GaudiHistoAlg>
5106 
5107 namespace ROOT {
5108 } // end of namespace ROOT for class ::ITupleTool
5109 
5110 namespace ROOT {
5111  // Wrappers around operator new
5112  static void *new_GaudiPythoncLcLTupleDecorator(void *p) {
5113  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::TupleDecorator : new ::GaudiPython::TupleDecorator;
5114  }
5115  static void *newArray_GaudiPythoncLcLTupleDecorator(Long_t nElements, void *p) {
5116  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::TupleDecorator[nElements] : new ::GaudiPython::TupleDecorator[nElements];
5117  }
5118  // Wrapper around operator delete
5119  static void delete_GaudiPythoncLcLTupleDecorator(void *p) {
5120  delete ((::GaudiPython::TupleDecorator*)p);
5121  }
5122  static void deleteArray_GaudiPythoncLcLTupleDecorator(void *p) {
5123  delete [] ((::GaudiPython::TupleDecorator*)p);
5124  }
5125  static void destruct_GaudiPythoncLcLTupleDecorator(void *p) {
5126  typedef ::GaudiPython::TupleDecorator current_t;
5127  ((current_t*)p)->~current_t();
5128  }
5129 } // end of namespace ROOT for class ::GaudiPython::TupleDecorator
5130 
5131 namespace ROOT {
5132  // Wrappers around operator new
5133  static void *new_GaudiPythoncLcLTupleAlgDecorator(void *p) {
5134  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::TupleAlgDecorator : new ::GaudiPython::TupleAlgDecorator;
5135  }
5136  static void *newArray_GaudiPythoncLcLTupleAlgDecorator(Long_t nElements, void *p) {
5137  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::TupleAlgDecorator[nElements] : new ::GaudiPython::TupleAlgDecorator[nElements];
5138  }
5139  // Wrapper around operator delete
5140  static void delete_GaudiPythoncLcLTupleAlgDecorator(void *p) {
5141  delete ((::GaudiPython::TupleAlgDecorator*)p);
5142  }
5143  static void deleteArray_GaudiPythoncLcLTupleAlgDecorator(void *p) {
5144  delete [] ((::GaudiPython::TupleAlgDecorator*)p);
5145  }
5146  static void destruct_GaudiPythoncLcLTupleAlgDecorator(void *p) {
5147  typedef ::GaudiPython::TupleAlgDecorator current_t;
5148  ((current_t*)p)->~current_t();
5149  }
5150 } // end of namespace ROOT for class ::GaudiPython::TupleAlgDecorator
5151 
5152 namespace ROOT {
5153  // Wrappers around operator new
5154  static void *new_GaudiPythoncLcLTupleToolDecorator(void *p) {
5155  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::TupleToolDecorator : new ::GaudiPython::TupleToolDecorator;
5156  }
5157  static void *newArray_GaudiPythoncLcLTupleToolDecorator(Long_t nElements, void *p) {
5158  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::TupleToolDecorator[nElements] : new ::GaudiPython::TupleToolDecorator[nElements];
5159  }
5160  // Wrapper around operator delete
5161  static void delete_GaudiPythoncLcLTupleToolDecorator(void *p) {
5162  delete ((::GaudiPython::TupleToolDecorator*)p);
5163  }
5164  static void deleteArray_GaudiPythoncLcLTupleToolDecorator(void *p) {
5165  delete [] ((::GaudiPython::TupleToolDecorator*)p);
5166  }
5167  static void destruct_GaudiPythoncLcLTupleToolDecorator(void *p) {
5168  typedef ::GaudiPython::TupleToolDecorator current_t;
5169  ((current_t*)p)->~current_t();
5170  }
5171 } // end of namespace ROOT for class ::GaudiPython::TupleToolDecorator
5172 
5173 namespace ROOT {
5174  // Wrappers around operator new
5175  static void *new_GaudiAlgcLcLPrint(void *p) {
5176  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print : new ::GaudiAlg::Print;
5177  }
5178  static void *newArray_GaudiAlgcLcLPrint(Long_t nElements, void *p) {
5179  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print[nElements] : new ::GaudiAlg::Print[nElements];
5180  }
5181  // Wrapper around operator delete
5182  static void delete_GaudiAlgcLcLPrint(void *p) {
5183  delete ((::GaudiAlg::Print*)p);
5184  }
5185  static void deleteArray_GaudiAlgcLcLPrint(void *p) {
5186  delete [] ((::GaudiAlg::Print*)p);
5187  }
5188  static void destruct_GaudiAlgcLcLPrint(void *p) {
5189  typedef ::GaudiAlg::Print current_t;
5190  ((current_t*)p)->~current_t();
5191  }
5192 } // end of namespace ROOT for class ::GaudiAlg::Print
5193 
5194 namespace ROOT {
5195  // Wrappers around operator new
5196  static void *new_GaudiAlgcLcLPrint1D(void *p) {
5197  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print1D : new ::GaudiAlg::Print1D;
5198  }
5199  static void *newArray_GaudiAlgcLcLPrint1D(Long_t nElements, void *p) {
5200  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print1D[nElements] : new ::GaudiAlg::Print1D[nElements];
5201  }
5202  // Wrapper around operator delete
5203  static void delete_GaudiAlgcLcLPrint1D(void *p) {
5204  delete ((::GaudiAlg::Print1D*)p);
5205  }
5206  static void deleteArray_GaudiAlgcLcLPrint1D(void *p) {
5207  delete [] ((::GaudiAlg::Print1D*)p);
5208  }
5209  static void destruct_GaudiAlgcLcLPrint1D(void *p) {
5210  typedef ::GaudiAlg::Print1D current_t;
5211  ((current_t*)p)->~current_t();
5212  }
5213 } // end of namespace ROOT for class ::GaudiAlg::Print1D
5214 
5215 namespace ROOT {
5216  // Wrappers around operator new
5217  static void *new_GaudiAlgcLcLPrint2D(void *p) {
5218  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print2D : new ::GaudiAlg::Print2D;
5219  }
5220  static void *newArray_GaudiAlgcLcLPrint2D(Long_t nElements, void *p) {
5221  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print2D[nElements] : new ::GaudiAlg::Print2D[nElements];
5222  }
5223  // Wrapper around operator delete
5224  static void delete_GaudiAlgcLcLPrint2D(void *p) {
5225  delete ((::GaudiAlg::Print2D*)p);
5226  }
5227  static void deleteArray_GaudiAlgcLcLPrint2D(void *p) {
5228  delete [] ((::GaudiAlg::Print2D*)p);
5229  }
5230  static void destruct_GaudiAlgcLcLPrint2D(void *p) {
5231  typedef ::GaudiAlg::Print2D current_t;
5232  ((current_t*)p)->~current_t();
5233  }
5234 } // end of namespace ROOT for class ::GaudiAlg::Print2D
5235 
5236 namespace ROOT {
5237  // Wrappers around operator new
5238  static void *new_GaudiAlgcLcLPrint3D(void *p) {
5239  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print3D : new ::GaudiAlg::Print3D;
5240  }
5241  static void *newArray_GaudiAlgcLcLPrint3D(Long_t nElements, void *p) {
5242  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print3D[nElements] : new ::GaudiAlg::Print3D[nElements];
5243  }
5244  // Wrapper around operator delete
5245  static void delete_GaudiAlgcLcLPrint3D(void *p) {
5246  delete ((::GaudiAlg::Print3D*)p);
5247  }
5248  static void deleteArray_GaudiAlgcLcLPrint3D(void *p) {
5249  delete [] ((::GaudiAlg::Print3D*)p);
5250  }
5251  static void destruct_GaudiAlgcLcLPrint3D(void *p) {
5252  typedef ::GaudiAlg::Print3D current_t;
5253  ((current_t*)p)->~current_t();
5254  }
5255 } // end of namespace ROOT for class ::GaudiAlg::Print3D
5256 
5257 namespace ROOT {
5258  // Wrappers around operator new
5259  static void *new_GaudiAlgcLcLPrint1DProf(void *p) {
5260  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print1DProf : new ::GaudiAlg::Print1DProf;
5261  }
5262  static void *newArray_GaudiAlgcLcLPrint1DProf(Long_t nElements, void *p) {
5263  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print1DProf[nElements] : new ::GaudiAlg::Print1DProf[nElements];
5264  }
5265  // Wrapper around operator delete
5266  static void delete_GaudiAlgcLcLPrint1DProf(void *p) {
5267  delete ((::GaudiAlg::Print1DProf*)p);
5268  }
5269  static void deleteArray_GaudiAlgcLcLPrint1DProf(void *p) {
5270  delete [] ((::GaudiAlg::Print1DProf*)p);
5271  }
5272  static void destruct_GaudiAlgcLcLPrint1DProf(void *p) {
5273  typedef ::GaudiAlg::Print1DProf current_t;
5274  ((current_t*)p)->~current_t();
5275  }
5276 } // end of namespace ROOT for class ::GaudiAlg::Print1DProf
5277 
5278 namespace ROOT {
5279  // Wrappers around operator new
5280  static void *new_GaudiAlgcLcLPrint2DProf(void *p) {
5281  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print2DProf : new ::GaudiAlg::Print2DProf;
5282  }
5283  static void *newArray_GaudiAlgcLcLPrint2DProf(Long_t nElements, void *p) {
5284  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print2DProf[nElements] : new ::GaudiAlg::Print2DProf[nElements];
5285  }
5286  // Wrapper around operator delete
5287  static void delete_GaudiAlgcLcLPrint2DProf(void *p) {
5288  delete ((::GaudiAlg::Print2DProf*)p);
5289  }
5290  static void deleteArray_GaudiAlgcLcLPrint2DProf(void *p) {
5291  delete [] ((::GaudiAlg::Print2DProf*)p);
5292  }
5293  static void destruct_GaudiAlgcLcLPrint2DProf(void *p) {
5294  typedef ::GaudiAlg::Print2DProf current_t;
5295  ((current_t*)p)->~current_t();
5296  }
5297 } // end of namespace ROOT for class ::GaudiAlg::Print2DProf
5298 
5299 namespace ROOT {
5300  // Wrappers around operator new
5301  static void *new_GaudiAlgcLcLPrintTuple(void *p) {
5302  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::PrintTuple : new ::GaudiAlg::PrintTuple;
5303  }
5304  static void *newArray_GaudiAlgcLcLPrintTuple(Long_t nElements, void *p) {
5305  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::PrintTuple[nElements] : new ::GaudiAlg::PrintTuple[nElements];
5306  }
5307  // Wrapper around operator delete
5308  static void delete_GaudiAlgcLcLPrintTuple(void *p) {
5309  delete ((::GaudiAlg::PrintTuple*)p);
5310  }
5311  static void deleteArray_GaudiAlgcLcLPrintTuple(void *p) {
5312  delete [] ((::GaudiAlg::PrintTuple*)p);
5313  }
5314  static void destruct_GaudiAlgcLcLPrintTuple(void *p) {
5315  typedef ::GaudiAlg::PrintTuple current_t;
5316  ((current_t*)p)->~current_t();
5317  }
5318 } // end of namespace ROOT for class ::GaudiAlg::PrintTuple
5319 
5320 namespace ROOT {
5321  // Wrappers around operator new
5322  static void *new_GaudiAlgcLcLPrintStat(void *p) {
5323  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::PrintStat : new ::GaudiAlg::PrintStat;
5324  }
5325  static void *newArray_GaudiAlgcLcLPrintStat(Long_t nElements, void *p) {
5326  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::PrintStat[nElements] : new ::GaudiAlg::PrintStat[nElements];
5327  }
5328  // Wrapper around operator delete
5329  static void delete_GaudiAlgcLcLPrintStat(void *p) {
5330  delete ((::GaudiAlg::PrintStat*)p);
5331  }
5332  static void deleteArray_GaudiAlgcLcLPrintStat(void *p) {
5333  delete [] ((::GaudiAlg::PrintStat*)p);
5334  }
5335  static void destruct_GaudiAlgcLcLPrintStat(void *p) {
5336  typedef ::GaudiAlg::PrintStat current_t;
5337  ((current_t*)p)->~current_t();
5338  }
5339 } // end of namespace ROOT for class ::GaudiAlg::PrintStat
5340 
5341 namespace ROOT {
5342 } // end of namespace ROOT for class ::IErrorTool
5343 
5344 namespace ROOT {
5345  // Wrapper around operator delete
5346  static void delete_IGenericTool(void *p) {
5347  delete ((::IGenericTool*)p);
5348  }
5349  static void deleteArray_IGenericTool(void *p) {
5350  delete [] ((::IGenericTool*)p);
5351  }
5352  static void destruct_IGenericTool(void *p) {
5353  typedef ::IGenericTool current_t;
5354  ((current_t*)p)->~current_t();
5355  }
5356 } // end of namespace ROOT for class ::IGenericTool
5357 
5358 namespace ROOT {
5359 } // end of namespace ROOT for class ::IHistoTool
5360 
5361 namespace ROOT {
5362  // Wrapper around operator delete
5363  static void delete_ISequencerTimerTool(void *p) {
5364  delete ((::ISequencerTimerTool*)p);
5365  }
5366  static void deleteArray_ISequencerTimerTool(void *p) {
5367  delete [] ((::ISequencerTimerTool*)p);
5368  }
5369  static void destruct_ISequencerTimerTool(void *p) {
5370  typedef ::ISequencerTimerTool current_t;
5371  ((current_t*)p)->~current_t();
5372  }
5373 } // end of namespace ROOT for class ::ISequencerTimerTool
5374 
5375 namespace ROOT {
5376  // Wrappers around operator new
5377  static void *new_GaudicLcLUtilscLcLAida2ROOT(void *p) {
5378  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::Aida2ROOT : new ::Gaudi::Utils::Aida2ROOT;
5379  }
5380  static void *newArray_GaudicLcLUtilscLcLAida2ROOT(Long_t nElements, void *p) {
5381  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::Aida2ROOT[nElements] : new ::Gaudi::Utils::Aida2ROOT[nElements];
5382  }
5383  // Wrapper around operator delete
5384  static void delete_GaudicLcLUtilscLcLAida2ROOT(void *p) {
5385  delete ((::Gaudi::Utils::Aida2ROOT*)p);
5386  }
5387  static void deleteArray_GaudicLcLUtilscLcLAida2ROOT(void *p) {
5388  delete [] ((::Gaudi::Utils::Aida2ROOT*)p);
5389  }
5390  static void destruct_GaudicLcLUtilscLcLAida2ROOT(void *p) {
5391  typedef ::Gaudi::Utils::Aida2ROOT current_t;
5392  ((current_t*)p)->~current_t();
5393  }
5394 } // end of namespace ROOT for class ::Gaudi::Utils::Aida2ROOT
5395 
5396 namespace ROOT {
5397  // Wrappers around operator new
5398  static void *new_GaudicLcLUtilscLcLHistoStats(void *p) {
5399  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::HistoStats : new ::Gaudi::Utils::HistoStats;
5400  }
5401  static void *newArray_GaudicLcLUtilscLcLHistoStats(Long_t nElements, void *p) {
5402  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::HistoStats[nElements] : new ::Gaudi::Utils::HistoStats[nElements];
5403  }
5404  // Wrapper around operator delete
5405  static void delete_GaudicLcLUtilscLcLHistoStats(void *p) {
5406  delete ((::Gaudi::Utils::HistoStats*)p);
5407  }
5408  static void deleteArray_GaudicLcLUtilscLcLHistoStats(void *p) {
5409  delete [] ((::Gaudi::Utils::HistoStats*)p);
5410  }
5411  static void destruct_GaudicLcLUtilscLcLHistoStats(void *p) {
5412  typedef ::Gaudi::Utils::HistoStats current_t;
5413  ((current_t*)p)->~current_t();
5414  }
5415 } // end of namespace ROOT for class ::Gaudi::Utils::HistoStats
5416 
5417 namespace ROOT {
5418  // Wrappers around operator new
5419  static void *new_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p) {
5420  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::Histos::HistoStrings : new ::Gaudi::Utils::Histos::HistoStrings;
5421  }
5422  static void *newArray_GaudicLcLUtilscLcLHistoscLcLHistoStrings(Long_t nElements, void *p) {
5423  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::Histos::HistoStrings[nElements] : new ::Gaudi::Utils::Histos::HistoStrings[nElements];
5424  }
5425  // Wrapper around operator delete
5426  static void delete_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p) {
5427  delete ((::Gaudi::Utils::Histos::HistoStrings*)p);
5428  }
5429  static void deleteArray_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p) {
5430  delete [] ((::Gaudi::Utils::Histos::HistoStrings*)p);
5431  }
5432  static void destruct_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p) {
5433  typedef ::Gaudi::Utils::Histos::HistoStrings current_t;
5434  ((current_t*)p)->~current_t();
5435  }
5436 } // end of namespace ROOT for class ::Gaudi::Utils::Histos::HistoStrings
5437 
5438 namespace ROOT {
5439  // Wrapper around operator delete
5440  static void delete_GaudicLcLIFileCatalog(void *p) {
5441  delete ((::Gaudi::IFileCatalog*)p);
5442  }
5443  static void deleteArray_GaudicLcLIFileCatalog(void *p) {
5444  delete [] ((::Gaudi::IFileCatalog*)p);
5445  }
5446  static void destruct_GaudicLcLIFileCatalog(void *p) {
5447  typedef ::Gaudi::IFileCatalog current_t;
5448  ((current_t*)p)->~current_t();
5449  }
5450 } // end of namespace ROOT for class ::Gaudi::IFileCatalog
5451 
5452 namespace ROOT {
5453  // Wrapper around operator delete
5454  static void delete_GaudicLcLIFileCatalogMgr(void *p) {
5455  delete ((::Gaudi::IFileCatalogMgr*)p);
5456  }
5457  static void deleteArray_GaudicLcLIFileCatalogMgr(void *p) {
5458  delete [] ((::Gaudi::IFileCatalogMgr*)p);
5459  }
5460  static void destruct_GaudicLcLIFileCatalogMgr(void *p) {
5461  typedef ::Gaudi::IFileCatalogMgr current_t;
5462  ((current_t*)p)->~current_t();
5463  }
5464 } // end of namespace ROOT for class ::Gaudi::IFileCatalogMgr
5465 
5466 namespace ROOT {
5467  // Wrapper around operator delete
5468  static void delete_GaudicLcLIDataConnection(void *p) {
5469  delete ((::Gaudi::IDataConnection*)p);
5470  }
5471  static void deleteArray_GaudicLcLIDataConnection(void *p) {
5472  delete [] ((::Gaudi::IDataConnection*)p);
5473  }
5474  static void destruct_GaudicLcLIDataConnection(void *p) {
5475  typedef ::Gaudi::IDataConnection current_t;
5476  ((current_t*)p)->~current_t();
5477  }
5478 } // end of namespace ROOT for class ::Gaudi::IDataConnection
5479 
5480 namespace ROOT {
5481  // Wrapper around operator delete
5482  static void delete_GaudicLcLIIODataManager(void *p) {
5483  delete ((::Gaudi::IIODataManager*)p);
5484  }
5485  static void deleteArray_GaudicLcLIIODataManager(void *p) {
5486  delete [] ((::Gaudi::IIODataManager*)p);
5487  }
5488  static void destruct_GaudicLcLIIODataManager(void *p) {
5489  typedef ::Gaudi::IIODataManager current_t;
5490  ((current_t*)p)->~current_t();
5491  }
5492 } // end of namespace ROOT for class ::Gaudi::IIODataManager
5493 
5494 namespace ROOT {
5495  // Wrappers around operator new
5496  static void *new___gnu_cxxcLcLdummy(void *p) {
5497  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::__gnu_cxx::dummy : new ::__gnu_cxx::dummy;
5498  }
5499  static void *newArray___gnu_cxxcLcLdummy(Long_t nElements, void *p) {
5500  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::__gnu_cxx::dummy[nElements] : new ::__gnu_cxx::dummy[nElements];
5501  }
5502  // Wrapper around operator delete
5503  static void delete___gnu_cxxcLcLdummy(void *p) {
5504  delete ((::__gnu_cxx::dummy*)p);
5505  }
5506  static void deleteArray___gnu_cxxcLcLdummy(void *p) {
5507  delete [] ((::__gnu_cxx::dummy*)p);
5508  }
5509  static void destruct___gnu_cxxcLcLdummy(void *p) {
5510  typedef ::__gnu_cxx::dummy current_t;
5511  ((current_t*)p)->~current_t();
5512  }
5513 } // end of namespace ROOT for class ::__gnu_cxx::dummy
5514 
5515 namespace ROOT {
5516  static TClass *vectorlEvectorlEdoublegRsPgR_Dictionary();
5517  static void vectorlEvectorlEdoublegRsPgR_TClassManip(TClass*);
5518  static void *new_vectorlEvectorlEdoublegRsPgR(void *p = 0);
5519  static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t size, void *p);
5520  static void delete_vectorlEvectorlEdoublegRsPgR(void *p);
5521  static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p);
5522  static void destruct_vectorlEvectorlEdoublegRsPgR(void *p);
5523 
5524  // Function generating the singleton type initializer
5525  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<vector<double> >*)
5526  {
5527  vector<vector<double> > *ptr = 0;
5528  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<vector<double> >));
5529  static ::ROOT::TGenericClassInfo
5530  instance("vector<vector<double> >", -2, "vector", 214,
5531  typeid(vector<vector<double> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5532  &vectorlEvectorlEdoublegRsPgR_Dictionary, isa_proxy, 4,
5533  sizeof(vector<vector<double> >) );
5534  instance.SetNew(&new_vectorlEvectorlEdoublegRsPgR);
5535  instance.SetNewArray(&newArray_vectorlEvectorlEdoublegRsPgR);
5536  instance.SetDelete(&delete_vectorlEvectorlEdoublegRsPgR);
5537  instance.SetDeleteArray(&deleteArray_vectorlEvectorlEdoublegRsPgR);
5538  instance.SetDestructor(&destruct_vectorlEvectorlEdoublegRsPgR);
5539  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<vector<double> > >()));
5540  return &instance;
5541  }
5542  // Static variable to force the class initialization
5543  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<vector<double> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5544 
5545  // Dictionary for non-ClassDef classes
5546  static TClass *vectorlEvectorlEdoublegRsPgR_Dictionary() {
5547  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<vector<double> >*)0x0)->GetClass();
5548  vectorlEvectorlEdoublegRsPgR_TClassManip(theClass);
5549  return theClass;
5550  }
5551 
5552  static void vectorlEvectorlEdoublegRsPgR_TClassManip(TClass* ){
5553  }
5554 
5555 } // end of namespace ROOT
5556 
5557 namespace ROOT {
5558  // Wrappers around operator new
5559  static void *new_vectorlEvectorlEdoublegRsPgR(void *p) {
5560  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<vector<double> > : new vector<vector<double> >;
5561  }
5562  static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t nElements, void *p) {
5563  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<vector<double> >[nElements] : new vector<vector<double> >[nElements];
5564  }
5565  // Wrapper around operator delete
5566  static void delete_vectorlEvectorlEdoublegRsPgR(void *p) {
5567  delete ((vector<vector<double> >*)p);
5568  }
5569  static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p) {
5570  delete [] ((vector<vector<double> >*)p);
5571  }
5572  static void destruct_vectorlEvectorlEdoublegRsPgR(void *p) {
5573  typedef vector<vector<double> > current_t;
5574  ((current_t*)p)->~current_t();
5575  }
5576 } // end of namespace ROOT for class vector<vector<double> >
5577 
5578 namespace ROOT {
5579  static TClass *vectorlEstringgR_Dictionary();
5580  static void vectorlEstringgR_TClassManip(TClass*);
5581  static void *new_vectorlEstringgR(void *p = 0);
5582  static void *newArray_vectorlEstringgR(Long_t size, void *p);
5583  static void delete_vectorlEstringgR(void *p);
5584  static void deleteArray_vectorlEstringgR(void *p);
5585  static void destruct_vectorlEstringgR(void *p);
5586 
5587  // Function generating the singleton type initializer
5588  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
5589  {
5590  vector<string> *ptr = 0;
5591  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>));
5592  static ::ROOT::TGenericClassInfo
5593  instance("vector<string>", -2, "vector", 214,
5594  typeid(vector<string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5595  &vectorlEstringgR_Dictionary, isa_proxy, 4,
5596  sizeof(vector<string>) );
5597  instance.SetNew(&new_vectorlEstringgR);
5598  instance.SetNewArray(&newArray_vectorlEstringgR);
5599  instance.SetDelete(&delete_vectorlEstringgR);
5600  instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
5601  instance.SetDestructor(&destruct_vectorlEstringgR);
5602  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));
5603  return &instance;
5604  }
5605  // Static variable to force the class initialization
5606  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<string>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5607 
5608  // Dictionary for non-ClassDef classes
5609  static TClass *vectorlEstringgR_Dictionary() {
5610  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<string>*)0x0)->GetClass();
5611  vectorlEstringgR_TClassManip(theClass);
5612  return theClass;
5613  }
5614 
5615  static void vectorlEstringgR_TClassManip(TClass* ){
5616  }
5617 
5618 } // end of namespace ROOT
5619 
5620 namespace ROOT {
5621  // Wrappers around operator new
5622  static void *new_vectorlEstringgR(void *p) {
5623  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<string> : new vector<string>;
5624  }
5625  static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
5626  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<string>[nElements] : new vector<string>[nElements];
5627  }
5628  // Wrapper around operator delete
5629  static void delete_vectorlEstringgR(void *p) {
5630  delete ((vector<string>*)p);
5631  }
5632  static void deleteArray_vectorlEstringgR(void *p) {
5633  delete [] ((vector<string>*)p);
5634  }
5635  static void destruct_vectorlEstringgR(void *p) {
5636  typedef vector<string> current_t;
5637  ((current_t*)p)->~current_t();
5638  }
5639 } // end of namespace ROOT for class vector<string>
5640 
5641 namespace ROOT {
5642  static TClass *vectorlEdoublegR_Dictionary();
5643  static void vectorlEdoublegR_TClassManip(TClass*);
5644  static void *new_vectorlEdoublegR(void *p = 0);
5645  static void *newArray_vectorlEdoublegR(Long_t size, void *p);
5646  static void delete_vectorlEdoublegR(void *p);
5647  static void deleteArray_vectorlEdoublegR(void *p);
5648  static void destruct_vectorlEdoublegR(void *p);
5649 
5650  // Function generating the singleton type initializer
5651  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
5652  {
5653  vector<double> *ptr = 0;
5654  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>));
5655  static ::ROOT::TGenericClassInfo
5656  instance("vector<double>", -2, "vector", 214,
5657  typeid(vector<double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5658  &vectorlEdoublegR_Dictionary, isa_proxy, 4,
5659  sizeof(vector<double>) );
5660  instance.SetNew(&new_vectorlEdoublegR);
5661  instance.SetNewArray(&newArray_vectorlEdoublegR);
5662  instance.SetDelete(&delete_vectorlEdoublegR);
5663  instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
5664  instance.SetDestructor(&destruct_vectorlEdoublegR);
5665  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
5666  return &instance;
5667  }
5668  // Static variable to force the class initialization
5669  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5670 
5671  // Dictionary for non-ClassDef classes
5672  static TClass *vectorlEdoublegR_Dictionary() {
5673  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<double>*)0x0)->GetClass();
5674  vectorlEdoublegR_TClassManip(theClass);
5675  return theClass;
5676  }
5677 
5678  static void vectorlEdoublegR_TClassManip(TClass* ){
5679  }
5680 
5681 } // end of namespace ROOT
5682 
5683 namespace ROOT {
5684  // Wrappers around operator new
5685  static void *new_vectorlEdoublegR(void *p) {
5686  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<double> : new vector<double>;
5687  }
5688  static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
5689  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
5690  }
5691  // Wrapper around operator delete
5692  static void delete_vectorlEdoublegR(void *p) {
5693  delete ((vector<double>*)p);
5694  }
5695  static void deleteArray_vectorlEdoublegR(void *p) {
5696  delete [] ((vector<double>*)p);
5697  }
5698  static void destruct_vectorlEdoublegR(void *p) {
5699  typedef vector<double> current_t;
5700  ((current_t*)p)->~current_t();
5701  }
5702 } // end of namespace ROOT for class vector<double>
5703 
5704 namespace ROOT {
5705  static TClass *vectorlEconstsPStatEntitymUgR_Dictionary();
5706  static void vectorlEconstsPStatEntitymUgR_TClassManip(TClass*);
5707  static void *new_vectorlEconstsPStatEntitymUgR(void *p = 0);
5708  static void *newArray_vectorlEconstsPStatEntitymUgR(Long_t size, void *p);
5709  static void delete_vectorlEconstsPStatEntitymUgR(void *p);
5710  static void deleteArray_vectorlEconstsPStatEntitymUgR(void *p);
5711  static void destruct_vectorlEconstsPStatEntitymUgR(void *p);
5712 
5713  // Function generating the singleton type initializer
5714  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<const StatEntity*>*)
5715  {
5716  vector<const StatEntity*> *ptr = 0;
5717  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<const StatEntity*>));
5718  static ::ROOT::TGenericClassInfo
5719  instance("vector<const StatEntity*>", -2, "vector", 214,
5720  typeid(vector<const StatEntity*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5721  &vectorlEconstsPStatEntitymUgR_Dictionary, isa_proxy, 4,
5722  sizeof(vector<const StatEntity*>) );
5723  instance.SetNew(&new_vectorlEconstsPStatEntitymUgR);
5724  instance.SetNewArray(&newArray_vectorlEconstsPStatEntitymUgR);
5725  instance.SetDelete(&delete_vectorlEconstsPStatEntitymUgR);
5726  instance.SetDeleteArray(&deleteArray_vectorlEconstsPStatEntitymUgR);
5727  instance.SetDestructor(&destruct_vectorlEconstsPStatEntitymUgR);
5728  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<const StatEntity*> >()));
5729  return &instance;
5730  }
5731  // Static variable to force the class initialization
5732  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<const StatEntity*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5733 
5734  // Dictionary for non-ClassDef classes
5735  static TClass *vectorlEconstsPStatEntitymUgR_Dictionary() {
5736  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<const StatEntity*>*)0x0)->GetClass();
5737  vectorlEconstsPStatEntitymUgR_TClassManip(theClass);
5738  return theClass;
5739  }
5740 
5741  static void vectorlEconstsPStatEntitymUgR_TClassManip(TClass* ){
5742  }
5743 
5744 } // end of namespace ROOT
5745 
5746 namespace ROOT {
5747  // Wrappers around operator new
5748  static void *new_vectorlEconstsPStatEntitymUgR(void *p) {
5749  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<const StatEntity*> : new vector<const StatEntity*>;
5750  }
5751  static void *newArray_vectorlEconstsPStatEntitymUgR(Long_t nElements, void *p) {
5752  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<const StatEntity*>[nElements] : new vector<const StatEntity*>[nElements];
5753  }
5754  // Wrapper around operator delete
5755  static void delete_vectorlEconstsPStatEntitymUgR(void *p) {
5756  delete ((vector<const StatEntity*>*)p);
5757  }
5758  static void deleteArray_vectorlEconstsPStatEntitymUgR(void *p) {
5759  delete [] ((vector<const StatEntity*>*)p);
5760  }
5761  static void destruct_vectorlEconstsPStatEntitymUgR(void *p) {
5762  typedef vector<const StatEntity*> current_t;
5763  ((current_t*)p)->~current_t();
5764  }
5765 } // end of namespace ROOT for class vector<const StatEntity*>
5766 
5767 namespace ROOT {
5768  static TClass *vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR_Dictionary();
5769  static void vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR_TClassManip(TClass*);
5770  static void *new_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p = 0);
5771  static void *newArray_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(Long_t size, void *p);
5772  static void delete_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p);
5773  static void deleteArray_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p);
5774  static void destruct_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p);
5775 
5776  // Function generating the singleton type initializer
5777  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<const Gaudi::Details::PropertyBase*>*)
5778  {
5779  vector<const Gaudi::Details::PropertyBase*> *ptr = 0;
5780  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<const Gaudi::Details::PropertyBase*>));
5781  static ::ROOT::TGenericClassInfo
5782  instance("vector<const Gaudi::Details::PropertyBase*>", -2, "vector", 214,
5783  typeid(vector<const Gaudi::Details::PropertyBase*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5784  &vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR_Dictionary, isa_proxy, 4,
5785  sizeof(vector<const Gaudi::Details::PropertyBase*>) );
5786  instance.SetNew(&new_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR);
5787  instance.SetNewArray(&newArray_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR);
5788  instance.SetDelete(&delete_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR);
5789  instance.SetDeleteArray(&deleteArray_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR);
5790  instance.SetDestructor(&destruct_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR);
5791  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<const Gaudi::Details::PropertyBase*> >()));
5792  return &instance;
5793  }
5794  // Static variable to force the class initialization
5795  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<const Gaudi::Details::PropertyBase*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5796 
5797  // Dictionary for non-ClassDef classes
5798  static TClass *vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR_Dictionary() {
5799  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<const Gaudi::Details::PropertyBase*>*)0x0)->GetClass();
5800  vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR_TClassManip(theClass);
5801  return theClass;
5802  }
5803 
5804  static void vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR_TClassManip(TClass* ){
5805  }
5806 
5807 } // end of namespace ROOT
5808 
5809 namespace ROOT {
5810  // Wrappers around operator new
5811  static void *new_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
5812  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<const Gaudi::Details::PropertyBase*> : new vector<const Gaudi::Details::PropertyBase*>;
5813  }
5814  static void *newArray_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(Long_t nElements, void *p) {
5815  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<const Gaudi::Details::PropertyBase*>[nElements] : new vector<const Gaudi::Details::PropertyBase*>[nElements];
5816  }
5817  // Wrapper around operator delete
5818  static void delete_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
5819  delete ((vector<const Gaudi::Details::PropertyBase*>*)p);
5820  }
5821  static void deleteArray_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
5822  delete [] ((vector<const Gaudi::Details::PropertyBase*>*)p);
5823  }
5824  static void destruct_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
5825  typedef vector<const Gaudi::Details::PropertyBase*> current_t;
5826  ((current_t*)p)->~current_t();
5827  }
5828 } // end of namespace ROOT for class vector<const Gaudi::Details::PropertyBase*>
5829 
5830 namespace ROOT {
5831  static TClass *vectorlEIServicemUgR_Dictionary();
5832  static void vectorlEIServicemUgR_TClassManip(TClass*);
5833  static void *new_vectorlEIServicemUgR(void *p = 0);
5834  static void *newArray_vectorlEIServicemUgR(Long_t size, void *p);
5835  static void delete_vectorlEIServicemUgR(void *p);
5836  static void deleteArray_vectorlEIServicemUgR(void *p);
5837  static void destruct_vectorlEIServicemUgR(void *p);
5838 
5839  // Function generating the singleton type initializer
5840  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<IService*>*)
5841  {
5842  vector<IService*> *ptr = 0;
5843  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<IService*>));
5844  static ::ROOT::TGenericClassInfo
5845  instance("vector<IService*>", -2, "vector", 214,
5846  typeid(vector<IService*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5847  &vectorlEIServicemUgR_Dictionary, isa_proxy, 4,
5848  sizeof(vector<IService*>) );
5849  instance.SetNew(&new_vectorlEIServicemUgR);
5850  instance.SetNewArray(&newArray_vectorlEIServicemUgR);
5851  instance.SetDelete(&delete_vectorlEIServicemUgR);
5852  instance.SetDeleteArray(&deleteArray_vectorlEIServicemUgR);
5853  instance.SetDestructor(&destruct_vectorlEIServicemUgR);
5854  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<IService*> >()));
5855  return &instance;
5856  }
5857  // Static variable to force the class initialization
5858  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<IService*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5859 
5860  // Dictionary for non-ClassDef classes
5861  static TClass *vectorlEIServicemUgR_Dictionary() {
5862  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<IService*>*)0x0)->GetClass();
5863  vectorlEIServicemUgR_TClassManip(theClass);
5864  return theClass;
5865  }
5866 
5867  static void vectorlEIServicemUgR_TClassManip(TClass* ){
5868  }
5869 
5870 } // end of namespace ROOT
5871 
5872 namespace ROOT {
5873  // Wrappers around operator new
5874  static void *new_vectorlEIServicemUgR(void *p) {
5875  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<IService*> : new vector<IService*>;
5876  }
5877  static void *newArray_vectorlEIServicemUgR(Long_t nElements, void *p) {
5878  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<IService*>[nElements] : new vector<IService*>[nElements];
5879  }
5880  // Wrapper around operator delete
5881  static void delete_vectorlEIServicemUgR(void *p) {
5882  delete ((vector<IService*>*)p);
5883  }
5884  static void deleteArray_vectorlEIServicemUgR(void *p) {
5885  delete [] ((vector<IService*>*)p);
5886  }
5887  static void destruct_vectorlEIServicemUgR(void *p) {
5888  typedef vector<IService*> current_t;
5889  ((current_t*)p)->~current_t();
5890  }
5891 } // end of namespace ROOT for class vector<IService*>
5892 
5893 namespace ROOT {
5894  static TClass *vectorlEIRegistrymUgR_Dictionary();
5895  static void vectorlEIRegistrymUgR_TClassManip(TClass*);
5896  static void *new_vectorlEIRegistrymUgR(void *p = 0);
5897  static void *newArray_vectorlEIRegistrymUgR(Long_t size, void *p);
5898  static void delete_vectorlEIRegistrymUgR(void *p);
5899  static void deleteArray_vectorlEIRegistrymUgR(void *p);
5900  static void destruct_vectorlEIRegistrymUgR(void *p);
5901 
5902  // Function generating the singleton type initializer
5903  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<IRegistry*>*)
5904  {
5905  vector<IRegistry*> *ptr = 0;
5906  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<IRegistry*>));
5907  static ::ROOT::TGenericClassInfo
5908  instance("vector<IRegistry*>", -2, "vector", 214,
5909  typeid(vector<IRegistry*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5910  &vectorlEIRegistrymUgR_Dictionary, isa_proxy, 4,
5911  sizeof(vector<IRegistry*>) );
5912  instance.SetNew(&new_vectorlEIRegistrymUgR);
5913  instance.SetNewArray(&newArray_vectorlEIRegistrymUgR);
5914  instance.SetDelete(&delete_vectorlEIRegistrymUgR);
5915  instance.SetDeleteArray(&deleteArray_vectorlEIRegistrymUgR);
5916  instance.SetDestructor(&destruct_vectorlEIRegistrymUgR);
5917  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<IRegistry*> >()));
5918  return &instance;
5919  }
5920  // Static variable to force the class initialization
5921  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<IRegistry*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5922 
5923  // Dictionary for non-ClassDef classes
5924  static TClass *vectorlEIRegistrymUgR_Dictionary() {
5925  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<IRegistry*>*)0x0)->GetClass();
5926  vectorlEIRegistrymUgR_TClassManip(theClass);
5927  return theClass;
5928  }
5929 
5930  static void vectorlEIRegistrymUgR_TClassManip(TClass* ){
5931  }
5932 
5933 } // end of namespace ROOT
5934 
5935 namespace ROOT {
5936  // Wrappers around operator new
5937  static void *new_vectorlEIRegistrymUgR(void *p) {
5938  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<IRegistry*> : new vector<IRegistry*>;
5939  }
5940  static void *newArray_vectorlEIRegistrymUgR(Long_t nElements, void *p) {
5941  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<IRegistry*>[nElements] : new vector<IRegistry*>[nElements];
5942  }
5943  // Wrapper around operator delete
5944  static void delete_vectorlEIRegistrymUgR(void *p) {
5945  delete ((vector<IRegistry*>*)p);
5946  }
5947  static void deleteArray_vectorlEIRegistrymUgR(void *p) {
5948  delete [] ((vector<IRegistry*>*)p);
5949  }
5950  static void destruct_vectorlEIRegistrymUgR(void *p) {
5951  typedef vector<IRegistry*> current_t;
5952  ((current_t*)p)->~current_t();
5953  }
5954 } // end of namespace ROOT for class vector<IRegistry*>
5955 
5956 namespace ROOT {
5957  static TClass *vectorlEIAlgToolmUgR_Dictionary();
5958  static void vectorlEIAlgToolmUgR_TClassManip(TClass*);
5959  static void *new_vectorlEIAlgToolmUgR(void *p = 0);
5960  static void *newArray_vectorlEIAlgToolmUgR(Long_t size, void *p);
5961  static void delete_vectorlEIAlgToolmUgR(void *p);
5962  static void deleteArray_vectorlEIAlgToolmUgR(void *p);
5963  static void destruct_vectorlEIAlgToolmUgR(void *p);
5964 
5965  // Function generating the singleton type initializer
5966  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<IAlgTool*>*)
5967  {
5968  vector<IAlgTool*> *ptr = 0;
5969  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<IAlgTool*>));
5970  static ::ROOT::TGenericClassInfo
5971  instance("vector<IAlgTool*>", -2, "vector", 214,
5972  typeid(vector<IAlgTool*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
5973  &vectorlEIAlgToolmUgR_Dictionary, isa_proxy, 4,
5974  sizeof(vector<IAlgTool*>) );
5975  instance.SetNew(&new_vectorlEIAlgToolmUgR);
5976  instance.SetNewArray(&newArray_vectorlEIAlgToolmUgR);
5977  instance.SetDelete(&delete_vectorlEIAlgToolmUgR);
5978  instance.SetDeleteArray(&deleteArray_vectorlEIAlgToolmUgR);
5979  instance.SetDestructor(&destruct_vectorlEIAlgToolmUgR);
5980  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<IAlgTool*> >()));
5981  return &instance;
5982  }
5983  // Static variable to force the class initialization
5984  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<IAlgTool*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
5985 
5986  // Dictionary for non-ClassDef classes
5987  static TClass *vectorlEIAlgToolmUgR_Dictionary() {
5988  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<IAlgTool*>*)0x0)->GetClass();
5989  vectorlEIAlgToolmUgR_TClassManip(theClass);
5990  return theClass;
5991  }
5992 
5993  static void vectorlEIAlgToolmUgR_TClassManip(TClass* ){
5994  }
5995 
5996 } // end of namespace ROOT
5997 
5998 namespace ROOT {
5999  // Wrappers around operator new
6000  static void *new_vectorlEIAlgToolmUgR(void *p) {
6001  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<IAlgTool*> : new vector<IAlgTool*>;
6002  }
6003  static void *newArray_vectorlEIAlgToolmUgR(Long_t nElements, void *p) {
6004  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<IAlgTool*>[nElements] : new vector<IAlgTool*>[nElements];
6005  }
6006  // Wrapper around operator delete
6007  static void delete_vectorlEIAlgToolmUgR(void *p) {
6008  delete ((vector<IAlgTool*>*)p);
6009  }
6010  static void deleteArray_vectorlEIAlgToolmUgR(void *p) {
6011  delete [] ((vector<IAlgTool*>*)p);
6012  }
6013  static void destruct_vectorlEIAlgToolmUgR(void *p) {
6014  typedef vector<IAlgTool*> current_t;
6015  ((current_t*)p)->~current_t();
6016  }
6017 } // end of namespace ROOT for class vector<IAlgTool*>
6018 
6019 namespace ROOT {
6020  static TClass *vectorlEGaudiAlgcLcLIDgR_Dictionary();
6021  static void vectorlEGaudiAlgcLcLIDgR_TClassManip(TClass*);
6022  static void *new_vectorlEGaudiAlgcLcLIDgR(void *p = 0);
6023  static void *newArray_vectorlEGaudiAlgcLcLIDgR(Long_t size, void *p);
6024  static void delete_vectorlEGaudiAlgcLcLIDgR(void *p);
6025  static void deleteArray_vectorlEGaudiAlgcLcLIDgR(void *p);
6026  static void destruct_vectorlEGaudiAlgcLcLIDgR(void *p);
6027 
6028  // Function generating the singleton type initializer
6029  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<GaudiAlg::ID>*)
6030  {
6031  vector<GaudiAlg::ID> *ptr = 0;
6032  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<GaudiAlg::ID>));
6033  static ::ROOT::TGenericClassInfo
6034  instance("vector<GaudiAlg::ID>", -2, "vector", 214,
6035  typeid(vector<GaudiAlg::ID>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6036  &vectorlEGaudiAlgcLcLIDgR_Dictionary, isa_proxy, 4,
6037  sizeof(vector<GaudiAlg::ID>) );
6038  instance.SetNew(&new_vectorlEGaudiAlgcLcLIDgR);
6039  instance.SetNewArray(&newArray_vectorlEGaudiAlgcLcLIDgR);
6040  instance.SetDelete(&delete_vectorlEGaudiAlgcLcLIDgR);
6041  instance.SetDeleteArray(&deleteArray_vectorlEGaudiAlgcLcLIDgR);
6042  instance.SetDestructor(&destruct_vectorlEGaudiAlgcLcLIDgR);
6043  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<GaudiAlg::ID> >()));
6044  return &instance;
6045  }
6046  // Static variable to force the class initialization
6047  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<GaudiAlg::ID>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6048 
6049  // Dictionary for non-ClassDef classes
6050  static TClass *vectorlEGaudiAlgcLcLIDgR_Dictionary() {
6051  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<GaudiAlg::ID>*)0x0)->GetClass();
6052  vectorlEGaudiAlgcLcLIDgR_TClassManip(theClass);
6053  return theClass;
6054  }
6055 
6056  static void vectorlEGaudiAlgcLcLIDgR_TClassManip(TClass* ){
6057  }
6058 
6059 } // end of namespace ROOT
6060 
6061 namespace ROOT {
6062  // Wrappers around operator new
6063  static void *new_vectorlEGaudiAlgcLcLIDgR(void *p) {
6064  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<GaudiAlg::ID> : new vector<GaudiAlg::ID>;
6065  }
6066  static void *newArray_vectorlEGaudiAlgcLcLIDgR(Long_t nElements, void *p) {
6067  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<GaudiAlg::ID>[nElements] : new vector<GaudiAlg::ID>[nElements];
6068  }
6069  // Wrapper around operator delete
6070  static void delete_vectorlEGaudiAlgcLcLIDgR(void *p) {
6071  delete ((vector<GaudiAlg::ID>*)p);
6072  }
6073  static void deleteArray_vectorlEGaudiAlgcLcLIDgR(void *p) {
6074  delete [] ((vector<GaudiAlg::ID>*)p);
6075  }
6076  static void destruct_vectorlEGaudiAlgcLcLIDgR(void *p) {
6077  typedef vector<GaudiAlg::ID> current_t;
6078  ((current_t*)p)->~current_t();
6079  }
6080 } // end of namespace ROOT for class vector<GaudiAlg::ID>
6081 
6082 namespace ROOT {
6083  static TClass *vectorlEGaudicLcLDetailscLcLPropertyBasemUgR_Dictionary();
6084  static void vectorlEGaudicLcLDetailscLcLPropertyBasemUgR_TClassManip(TClass*);
6085  static void *new_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p = 0);
6086  static void *newArray_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(Long_t size, void *p);
6087  static void delete_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p);
6088  static void deleteArray_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p);
6089  static void destruct_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p);
6090 
6091  // Function generating the singleton type initializer
6092  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Gaudi::Details::PropertyBase*>*)
6093  {
6094  vector<Gaudi::Details::PropertyBase*> *ptr = 0;
6095  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Gaudi::Details::PropertyBase*>));
6096  static ::ROOT::TGenericClassInfo
6097  instance("vector<Gaudi::Details::PropertyBase*>", -2, "vector", 214,
6098  typeid(vector<Gaudi::Details::PropertyBase*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6099  &vectorlEGaudicLcLDetailscLcLPropertyBasemUgR_Dictionary, isa_proxy, 4,
6100  sizeof(vector<Gaudi::Details::PropertyBase*>) );
6101  instance.SetNew(&new_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR);
6102  instance.SetNewArray(&newArray_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR);
6103  instance.SetDelete(&delete_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR);
6104  instance.SetDeleteArray(&deleteArray_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR);
6105  instance.SetDestructor(&destruct_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR);
6106  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Gaudi::Details::PropertyBase*> >()));
6107  return &instance;
6108  }
6109  // Static variable to force the class initialization
6110  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<Gaudi::Details::PropertyBase*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6111 
6112  // Dictionary for non-ClassDef classes
6113  static TClass *vectorlEGaudicLcLDetailscLcLPropertyBasemUgR_Dictionary() {
6114  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<Gaudi::Details::PropertyBase*>*)0x0)->GetClass();
6115  vectorlEGaudicLcLDetailscLcLPropertyBasemUgR_TClassManip(theClass);
6116  return theClass;
6117  }
6118 
6119  static void vectorlEGaudicLcLDetailscLcLPropertyBasemUgR_TClassManip(TClass* ){
6120  }
6121 
6122 } // end of namespace ROOT
6123 
6124 namespace ROOT {
6125  // Wrappers around operator new
6126  static void *new_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
6127  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<Gaudi::Details::PropertyBase*> : new vector<Gaudi::Details::PropertyBase*>;
6128  }
6129  static void *newArray_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(Long_t nElements, void *p) {
6130  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<Gaudi::Details::PropertyBase*>[nElements] : new vector<Gaudi::Details::PropertyBase*>[nElements];
6131  }
6132  // Wrapper around operator delete
6133  static void delete_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
6134  delete ((vector<Gaudi::Details::PropertyBase*>*)p);
6135  }
6136  static void deleteArray_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
6137  delete [] ((vector<Gaudi::Details::PropertyBase*>*)p);
6138  }
6139  static void destruct_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
6140  typedef vector<Gaudi::Details::PropertyBase*> current_t;
6141  ((current_t*)p)->~current_t();
6142  }
6143 } // end of namespace ROOT for class vector<Gaudi::Details::PropertyBase*>
6144 
6145 namespace ROOT {
6146  static TClass *vectorlEAIDAcLcLIProfile2DmUgR_Dictionary();
6147  static void vectorlEAIDAcLcLIProfile2DmUgR_TClassManip(TClass*);
6148  static void *new_vectorlEAIDAcLcLIProfile2DmUgR(void *p = 0);
6149  static void *newArray_vectorlEAIDAcLcLIProfile2DmUgR(Long_t size, void *p);
6150  static void delete_vectorlEAIDAcLcLIProfile2DmUgR(void *p);
6151  static void deleteArray_vectorlEAIDAcLcLIProfile2DmUgR(void *p);
6152  static void destruct_vectorlEAIDAcLcLIProfile2DmUgR(void *p);
6153 
6154  // Function generating the singleton type initializer
6155  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AIDA::IProfile2D*>*)
6156  {
6157  vector<AIDA::IProfile2D*> *ptr = 0;
6158  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AIDA::IProfile2D*>));
6159  static ::ROOT::TGenericClassInfo
6160  instance("vector<AIDA::IProfile2D*>", -2, "vector", 214,
6161  typeid(vector<AIDA::IProfile2D*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6162  &vectorlEAIDAcLcLIProfile2DmUgR_Dictionary, isa_proxy, 4,
6163  sizeof(vector<AIDA::IProfile2D*>) );
6164  instance.SetNew(&new_vectorlEAIDAcLcLIProfile2DmUgR);
6165  instance.SetNewArray(&newArray_vectorlEAIDAcLcLIProfile2DmUgR);
6166  instance.SetDelete(&delete_vectorlEAIDAcLcLIProfile2DmUgR);
6167  instance.SetDeleteArray(&deleteArray_vectorlEAIDAcLcLIProfile2DmUgR);
6168  instance.SetDestructor(&destruct_vectorlEAIDAcLcLIProfile2DmUgR);
6169  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AIDA::IProfile2D*> >()));
6170  return &instance;
6171  }
6172  // Static variable to force the class initialization
6173  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<AIDA::IProfile2D*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6174 
6175  // Dictionary for non-ClassDef classes
6176  static TClass *vectorlEAIDAcLcLIProfile2DmUgR_Dictionary() {
6177  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<AIDA::IProfile2D*>*)0x0)->GetClass();
6178  vectorlEAIDAcLcLIProfile2DmUgR_TClassManip(theClass);
6179  return theClass;
6180  }
6181 
6182  static void vectorlEAIDAcLcLIProfile2DmUgR_TClassManip(TClass* ){
6183  }
6184 
6185 } // end of namespace ROOT
6186 
6187 namespace ROOT {
6188  // Wrappers around operator new
6189  static void *new_vectorlEAIDAcLcLIProfile2DmUgR(void *p) {
6190  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IProfile2D*> : new vector<AIDA::IProfile2D*>;
6191  }
6192  static void *newArray_vectorlEAIDAcLcLIProfile2DmUgR(Long_t nElements, void *p) {
6193  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IProfile2D*>[nElements] : new vector<AIDA::IProfile2D*>[nElements];
6194  }
6195  // Wrapper around operator delete
6196  static void delete_vectorlEAIDAcLcLIProfile2DmUgR(void *p) {
6197  delete ((vector<AIDA::IProfile2D*>*)p);
6198  }
6199  static void deleteArray_vectorlEAIDAcLcLIProfile2DmUgR(void *p) {
6200  delete [] ((vector<AIDA::IProfile2D*>*)p);
6201  }
6202  static void destruct_vectorlEAIDAcLcLIProfile2DmUgR(void *p) {
6203  typedef vector<AIDA::IProfile2D*> current_t;
6204  ((current_t*)p)->~current_t();
6205  }
6206 } // end of namespace ROOT for class vector<AIDA::IProfile2D*>
6207 
6208 namespace ROOT {
6209  static TClass *vectorlEAIDAcLcLIProfile1DmUgR_Dictionary();
6210  static void vectorlEAIDAcLcLIProfile1DmUgR_TClassManip(TClass*);
6211  static void *new_vectorlEAIDAcLcLIProfile1DmUgR(void *p = 0);
6212  static void *newArray_vectorlEAIDAcLcLIProfile1DmUgR(Long_t size, void *p);
6213  static void delete_vectorlEAIDAcLcLIProfile1DmUgR(void *p);
6214  static void deleteArray_vectorlEAIDAcLcLIProfile1DmUgR(void *p);
6215  static void destruct_vectorlEAIDAcLcLIProfile1DmUgR(void *p);
6216 
6217  // Function generating the singleton type initializer
6218  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AIDA::IProfile1D*>*)
6219  {
6220  vector<AIDA::IProfile1D*> *ptr = 0;
6221  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AIDA::IProfile1D*>));
6222  static ::ROOT::TGenericClassInfo
6223  instance("vector<AIDA::IProfile1D*>", -2, "vector", 214,
6224  typeid(vector<AIDA::IProfile1D*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6225  &vectorlEAIDAcLcLIProfile1DmUgR_Dictionary, isa_proxy, 4,
6226  sizeof(vector<AIDA::IProfile1D*>) );
6227  instance.SetNew(&new_vectorlEAIDAcLcLIProfile1DmUgR);
6228  instance.SetNewArray(&newArray_vectorlEAIDAcLcLIProfile1DmUgR);
6229  instance.SetDelete(&delete_vectorlEAIDAcLcLIProfile1DmUgR);
6230  instance.SetDeleteArray(&deleteArray_vectorlEAIDAcLcLIProfile1DmUgR);
6231  instance.SetDestructor(&destruct_vectorlEAIDAcLcLIProfile1DmUgR);
6232  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AIDA::IProfile1D*> >()));
6233  return &instance;
6234  }
6235  // Static variable to force the class initialization
6236  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<AIDA::IProfile1D*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6237 
6238  // Dictionary for non-ClassDef classes
6239  static TClass *vectorlEAIDAcLcLIProfile1DmUgR_Dictionary() {
6240  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<AIDA::IProfile1D*>*)0x0)->GetClass();
6241  vectorlEAIDAcLcLIProfile1DmUgR_TClassManip(theClass);
6242  return theClass;
6243  }
6244 
6245  static void vectorlEAIDAcLcLIProfile1DmUgR_TClassManip(TClass* ){
6246  }
6247 
6248 } // end of namespace ROOT
6249 
6250 namespace ROOT {
6251  // Wrappers around operator new
6252  static void *new_vectorlEAIDAcLcLIProfile1DmUgR(void *p) {
6253  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IProfile1D*> : new vector<AIDA::IProfile1D*>;
6254  }
6255  static void *newArray_vectorlEAIDAcLcLIProfile1DmUgR(Long_t nElements, void *p) {
6256  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IProfile1D*>[nElements] : new vector<AIDA::IProfile1D*>[nElements];
6257  }
6258  // Wrapper around operator delete
6259  static void delete_vectorlEAIDAcLcLIProfile1DmUgR(void *p) {
6260  delete ((vector<AIDA::IProfile1D*>*)p);
6261  }
6262  static void deleteArray_vectorlEAIDAcLcLIProfile1DmUgR(void *p) {
6263  delete [] ((vector<AIDA::IProfile1D*>*)p);
6264  }
6265  static void destruct_vectorlEAIDAcLcLIProfile1DmUgR(void *p) {
6266  typedef vector<AIDA::IProfile1D*> current_t;
6267  ((current_t*)p)->~current_t();
6268  }
6269 } // end of namespace ROOT for class vector<AIDA::IProfile1D*>
6270 
6271 namespace ROOT {
6272  static TClass *vectorlEAIDAcLcLIHistogram3DmUgR_Dictionary();
6273  static void vectorlEAIDAcLcLIHistogram3DmUgR_TClassManip(TClass*);
6274  static void *new_vectorlEAIDAcLcLIHistogram3DmUgR(void *p = 0);
6275  static void *newArray_vectorlEAIDAcLcLIHistogram3DmUgR(Long_t size, void *p);
6276  static void delete_vectorlEAIDAcLcLIHistogram3DmUgR(void *p);
6277  static void deleteArray_vectorlEAIDAcLcLIHistogram3DmUgR(void *p);
6278  static void destruct_vectorlEAIDAcLcLIHistogram3DmUgR(void *p);
6279 
6280  // Function generating the singleton type initializer
6281  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AIDA::IHistogram3D*>*)
6282  {
6283  vector<AIDA::IHistogram3D*> *ptr = 0;
6284  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AIDA::IHistogram3D*>));
6285  static ::ROOT::TGenericClassInfo
6286  instance("vector<AIDA::IHistogram3D*>", -2, "vector", 214,
6287  typeid(vector<AIDA::IHistogram3D*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6288  &vectorlEAIDAcLcLIHistogram3DmUgR_Dictionary, isa_proxy, 4,
6289  sizeof(vector<AIDA::IHistogram3D*>) );
6290  instance.SetNew(&new_vectorlEAIDAcLcLIHistogram3DmUgR);
6291  instance.SetNewArray(&newArray_vectorlEAIDAcLcLIHistogram3DmUgR);
6292  instance.SetDelete(&delete_vectorlEAIDAcLcLIHistogram3DmUgR);
6293  instance.SetDeleteArray(&deleteArray_vectorlEAIDAcLcLIHistogram3DmUgR);
6294  instance.SetDestructor(&destruct_vectorlEAIDAcLcLIHistogram3DmUgR);
6295  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AIDA::IHistogram3D*> >()));
6296  return &instance;
6297  }
6298  // Static variable to force the class initialization
6299  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<AIDA::IHistogram3D*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6300 
6301  // Dictionary for non-ClassDef classes
6302  static TClass *vectorlEAIDAcLcLIHistogram3DmUgR_Dictionary() {
6303  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<AIDA::IHistogram3D*>*)0x0)->GetClass();
6304  vectorlEAIDAcLcLIHistogram3DmUgR_TClassManip(theClass);
6305  return theClass;
6306  }
6307 
6308  static void vectorlEAIDAcLcLIHistogram3DmUgR_TClassManip(TClass* ){
6309  }
6310 
6311 } // end of namespace ROOT
6312 
6313 namespace ROOT {
6314  // Wrappers around operator new
6315  static void *new_vectorlEAIDAcLcLIHistogram3DmUgR(void *p) {
6316  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IHistogram3D*> : new vector<AIDA::IHistogram3D*>;
6317  }
6318  static void *newArray_vectorlEAIDAcLcLIHistogram3DmUgR(Long_t nElements, void *p) {
6319  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IHistogram3D*>[nElements] : new vector<AIDA::IHistogram3D*>[nElements];
6320  }
6321  // Wrapper around operator delete
6322  static void delete_vectorlEAIDAcLcLIHistogram3DmUgR(void *p) {
6323  delete ((vector<AIDA::IHistogram3D*>*)p);
6324  }
6325  static void deleteArray_vectorlEAIDAcLcLIHistogram3DmUgR(void *p) {
6326  delete [] ((vector<AIDA::IHistogram3D*>*)p);
6327  }
6328  static void destruct_vectorlEAIDAcLcLIHistogram3DmUgR(void *p) {
6329  typedef vector<AIDA::IHistogram3D*> current_t;
6330  ((current_t*)p)->~current_t();
6331  }
6332 } // end of namespace ROOT for class vector<AIDA::IHistogram3D*>
6333 
6334 namespace ROOT {
6335  static TClass *vectorlEAIDAcLcLIHistogram2DmUgR_Dictionary();
6336  static void vectorlEAIDAcLcLIHistogram2DmUgR_TClassManip(TClass*);
6337  static void *new_vectorlEAIDAcLcLIHistogram2DmUgR(void *p = 0);
6338  static void *newArray_vectorlEAIDAcLcLIHistogram2DmUgR(Long_t size, void *p);
6339  static void delete_vectorlEAIDAcLcLIHistogram2DmUgR(void *p);
6340  static void deleteArray_vectorlEAIDAcLcLIHistogram2DmUgR(void *p);
6341  static void destruct_vectorlEAIDAcLcLIHistogram2DmUgR(void *p);
6342 
6343  // Function generating the singleton type initializer
6344  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AIDA::IHistogram2D*>*)
6345  {
6346  vector<AIDA::IHistogram2D*> *ptr = 0;
6347  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AIDA::IHistogram2D*>));
6348  static ::ROOT::TGenericClassInfo
6349  instance("vector<AIDA::IHistogram2D*>", -2, "vector", 214,
6350  typeid(vector<AIDA::IHistogram2D*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6351  &vectorlEAIDAcLcLIHistogram2DmUgR_Dictionary, isa_proxy, 4,
6352  sizeof(vector<AIDA::IHistogram2D*>) );
6353  instance.SetNew(&new_vectorlEAIDAcLcLIHistogram2DmUgR);
6354  instance.SetNewArray(&newArray_vectorlEAIDAcLcLIHistogram2DmUgR);
6355  instance.SetDelete(&delete_vectorlEAIDAcLcLIHistogram2DmUgR);
6356  instance.SetDeleteArray(&deleteArray_vectorlEAIDAcLcLIHistogram2DmUgR);
6357  instance.SetDestructor(&destruct_vectorlEAIDAcLcLIHistogram2DmUgR);
6358  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AIDA::IHistogram2D*> >()));
6359  return &instance;
6360  }
6361  // Static variable to force the class initialization
6362  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<AIDA::IHistogram2D*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6363 
6364  // Dictionary for non-ClassDef classes
6365  static TClass *vectorlEAIDAcLcLIHistogram2DmUgR_Dictionary() {
6366  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<AIDA::IHistogram2D*>*)0x0)->GetClass();
6367  vectorlEAIDAcLcLIHistogram2DmUgR_TClassManip(theClass);
6368  return theClass;
6369  }
6370 
6371  static void vectorlEAIDAcLcLIHistogram2DmUgR_TClassManip(TClass* ){
6372  }
6373 
6374 } // end of namespace ROOT
6375 
6376 namespace ROOT {
6377  // Wrappers around operator new
6378  static void *new_vectorlEAIDAcLcLIHistogram2DmUgR(void *p) {
6379  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IHistogram2D*> : new vector<AIDA::IHistogram2D*>;
6380  }
6381  static void *newArray_vectorlEAIDAcLcLIHistogram2DmUgR(Long_t nElements, void *p) {
6382  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IHistogram2D*>[nElements] : new vector<AIDA::IHistogram2D*>[nElements];
6383  }
6384  // Wrapper around operator delete
6385  static void delete_vectorlEAIDAcLcLIHistogram2DmUgR(void *p) {
6386  delete ((vector<AIDA::IHistogram2D*>*)p);
6387  }
6388  static void deleteArray_vectorlEAIDAcLcLIHistogram2DmUgR(void *p) {
6389  delete [] ((vector<AIDA::IHistogram2D*>*)p);
6390  }
6391  static void destruct_vectorlEAIDAcLcLIHistogram2DmUgR(void *p) {
6392  typedef vector<AIDA::IHistogram2D*> current_t;
6393  ((current_t*)p)->~current_t();
6394  }
6395 } // end of namespace ROOT for class vector<AIDA::IHistogram2D*>
6396 
6397 namespace ROOT {
6398  static TClass *vectorlEAIDAcLcLIHistogram1DmUgR_Dictionary();
6399  static void vectorlEAIDAcLcLIHistogram1DmUgR_TClassManip(TClass*);
6400  static void *new_vectorlEAIDAcLcLIHistogram1DmUgR(void *p = 0);
6401  static void *newArray_vectorlEAIDAcLcLIHistogram1DmUgR(Long_t size, void *p);
6402  static void delete_vectorlEAIDAcLcLIHistogram1DmUgR(void *p);
6403  static void deleteArray_vectorlEAIDAcLcLIHistogram1DmUgR(void *p);
6404  static void destruct_vectorlEAIDAcLcLIHistogram1DmUgR(void *p);
6405 
6406  // Function generating the singleton type initializer
6407  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AIDA::IHistogram1D*>*)
6408  {
6409  vector<AIDA::IHistogram1D*> *ptr = 0;
6410  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AIDA::IHistogram1D*>));
6411  static ::ROOT::TGenericClassInfo
6412  instance("vector<AIDA::IHistogram1D*>", -2, "vector", 214,
6413  typeid(vector<AIDA::IHistogram1D*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6414  &vectorlEAIDAcLcLIHistogram1DmUgR_Dictionary, isa_proxy, 4,
6415  sizeof(vector<AIDA::IHistogram1D*>) );
6416  instance.SetNew(&new_vectorlEAIDAcLcLIHistogram1DmUgR);
6417  instance.SetNewArray(&newArray_vectorlEAIDAcLcLIHistogram1DmUgR);
6418  instance.SetDelete(&delete_vectorlEAIDAcLcLIHistogram1DmUgR);
6419  instance.SetDeleteArray(&deleteArray_vectorlEAIDAcLcLIHistogram1DmUgR);
6420  instance.SetDestructor(&destruct_vectorlEAIDAcLcLIHistogram1DmUgR);
6421  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AIDA::IHistogram1D*> >()));
6422  return &instance;
6423  }
6424  // Static variable to force the class initialization
6425  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<AIDA::IHistogram1D*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6426 
6427  // Dictionary for non-ClassDef classes
6428  static TClass *vectorlEAIDAcLcLIHistogram1DmUgR_Dictionary() {
6429  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<AIDA::IHistogram1D*>*)0x0)->GetClass();
6430  vectorlEAIDAcLcLIHistogram1DmUgR_TClassManip(theClass);
6431  return theClass;
6432  }
6433 
6434  static void vectorlEAIDAcLcLIHistogram1DmUgR_TClassManip(TClass* ){
6435  }
6436 
6437 } // end of namespace ROOT
6438 
6439 namespace ROOT {
6440  // Wrappers around operator new
6441  static void *new_vectorlEAIDAcLcLIHistogram1DmUgR(void *p) {
6442  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IHistogram1D*> : new vector<AIDA::IHistogram1D*>;
6443  }
6444  static void *newArray_vectorlEAIDAcLcLIHistogram1DmUgR(Long_t nElements, void *p) {
6445  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IHistogram1D*>[nElements] : new vector<AIDA::IHistogram1D*>[nElements];
6446  }
6447  // Wrapper around operator delete
6448  static void delete_vectorlEAIDAcLcLIHistogram1DmUgR(void *p) {
6449  delete ((vector<AIDA::IHistogram1D*>*)p);
6450  }
6451  static void deleteArray_vectorlEAIDAcLcLIHistogram1DmUgR(void *p) {
6452  delete [] ((vector<AIDA::IHistogram1D*>*)p);
6453  }
6454  static void destruct_vectorlEAIDAcLcLIHistogram1DmUgR(void *p) {
6455  typedef vector<AIDA::IHistogram1D*> current_t;
6456  ((current_t*)p)->~current_t();
6457  }
6458 } // end of namespace ROOT for class vector<AIDA::IHistogram1D*>
6459 
6460 namespace ROOT {
6461  static TClass *maplEstringcOstringgR_Dictionary();
6462  static void maplEstringcOstringgR_TClassManip(TClass*);
6463  static void *new_maplEstringcOstringgR(void *p = 0);
6464  static void *newArray_maplEstringcOstringgR(Long_t size, void *p);
6465  static void delete_maplEstringcOstringgR(void *p);
6466  static void deleteArray_maplEstringcOstringgR(void *p);
6467  static void destruct_maplEstringcOstringgR(void *p);
6468 
6469  // Function generating the singleton type initializer
6470  static TGenericClassInfo *GenerateInitInstanceLocal(const map<string,string>*)
6471  {
6472  map<string,string> *ptr = 0;
6473  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<string,string>));
6474  static ::ROOT::TGenericClassInfo
6475  instance("map<string,string>", -2, "map", 96,
6476  typeid(map<string,string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6477  &maplEstringcOstringgR_Dictionary, isa_proxy, 4,
6478  sizeof(map<string,string>) );
6479  instance.SetNew(&new_maplEstringcOstringgR);
6480  instance.SetNewArray(&newArray_maplEstringcOstringgR);
6481  instance.SetDelete(&delete_maplEstringcOstringgR);
6482  instance.SetDeleteArray(&deleteArray_maplEstringcOstringgR);
6483  instance.SetDestructor(&destruct_maplEstringcOstringgR);
6484  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<string,string> >()));
6485  return &instance;
6486  }
6487  // Static variable to force the class initialization
6488  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const map<string,string>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6489 
6490  // Dictionary for non-ClassDef classes
6491  static TClass *maplEstringcOstringgR_Dictionary() {
6492  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map<string,string>*)0x0)->GetClass();
6493  maplEstringcOstringgR_TClassManip(theClass);
6494  return theClass;
6495  }
6496 
6497  static void maplEstringcOstringgR_TClassManip(TClass* ){
6498  }
6499 
6500 } // end of namespace ROOT
6501 
6502 namespace ROOT {
6503  // Wrappers around operator new
6504  static void *new_maplEstringcOstringgR(void *p) {
6505  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<string,string> : new map<string,string>;
6506  }
6507  static void *newArray_maplEstringcOstringgR(Long_t nElements, void *p) {
6508  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<string,string>[nElements] : new map<string,string>[nElements];
6509  }
6510  // Wrapper around operator delete
6511  static void delete_maplEstringcOstringgR(void *p) {
6512  delete ((map<string,string>*)p);
6513  }
6514  static void deleteArray_maplEstringcOstringgR(void *p) {
6515  delete [] ((map<string,string>*)p);
6516  }
6517  static void destruct_maplEstringcOstringgR(void *p) {
6518  typedef map<string,string> current_t;
6519  ((current_t*)p)->~current_t();
6520  }
6521 } // end of namespace ROOT for class map<string,string>
6522 
6523 namespace ROOT {
6524  static TClass *listlEIServicemUgR_Dictionary();
6525  static void listlEIServicemUgR_TClassManip(TClass*);
6526  static void *new_listlEIServicemUgR(void *p = 0);
6527  static void *newArray_listlEIServicemUgR(Long_t size, void *p);
6528  static void delete_listlEIServicemUgR(void *p);
6529  static void deleteArray_listlEIServicemUgR(void *p);
6530  static void destruct_listlEIServicemUgR(void *p);
6531 
6532  // Function generating the singleton type initializer
6533  static TGenericClassInfo *GenerateInitInstanceLocal(const list<IService*>*)
6534  {
6535  list<IService*> *ptr = 0;
6536  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list<IService*>));
6537  static ::ROOT::TGenericClassInfo
6538  instance("list<IService*>", -2, "list", 503,
6539  typeid(list<IService*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6540  &listlEIServicemUgR_Dictionary, isa_proxy, 4,
6541  sizeof(list<IService*>) );
6542  instance.SetNew(&new_listlEIServicemUgR);
6543  instance.SetNewArray(&newArray_listlEIServicemUgR);
6544  instance.SetDelete(&delete_listlEIServicemUgR);
6545  instance.SetDeleteArray(&deleteArray_listlEIServicemUgR);
6546  instance.SetDestructor(&destruct_listlEIServicemUgR);
6547  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< list<IService*> >()));
6548  return &instance;
6549  }
6550  // Static variable to force the class initialization
6551  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const list<IService*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6552 
6553  // Dictionary for non-ClassDef classes
6554  static TClass *listlEIServicemUgR_Dictionary() {
6555  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const list<IService*>*)0x0)->GetClass();
6556  listlEIServicemUgR_TClassManip(theClass);
6557  return theClass;
6558  }
6559 
6560  static void listlEIServicemUgR_TClassManip(TClass* ){
6561  }
6562 
6563 } // end of namespace ROOT
6564 
6565 namespace ROOT {
6566  // Wrappers around operator new
6567  static void *new_listlEIServicemUgR(void *p) {
6568  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list<IService*> : new list<IService*>;
6569  }
6570  static void *newArray_listlEIServicemUgR(Long_t nElements, void *p) {
6571  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list<IService*>[nElements] : new list<IService*>[nElements];
6572  }
6573  // Wrapper around operator delete
6574  static void delete_listlEIServicemUgR(void *p) {
6575  delete ((list<IService*>*)p);
6576  }
6577  static void deleteArray_listlEIServicemUgR(void *p) {
6578  delete [] ((list<IService*>*)p);
6579  }
6580  static void destruct_listlEIServicemUgR(void *p) {
6581  typedef list<IService*> current_t;
6582  ((current_t*)p)->~current_t();
6583  }
6584 } // end of namespace ROOT for class list<IService*>
6585 
6586 namespace ROOT {
6587  static TClass *listlEIAlgorithmmUgR_Dictionary();
6588  static void listlEIAlgorithmmUgR_TClassManip(TClass*);
6589  static void *new_listlEIAlgorithmmUgR(void *p = 0);
6590  static void *newArray_listlEIAlgorithmmUgR(Long_t size, void *p);
6591  static void delete_listlEIAlgorithmmUgR(void *p);
6592  static void deleteArray_listlEIAlgorithmmUgR(void *p);
6593  static void destruct_listlEIAlgorithmmUgR(void *p);
6594 
6595  // Function generating the singleton type initializer
6596  static TGenericClassInfo *GenerateInitInstanceLocal(const list<IAlgorithm*>*)
6597  {
6598  list<IAlgorithm*> *ptr = 0;
6599  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list<IAlgorithm*>));
6600  static ::ROOT::TGenericClassInfo
6601  instance("list<IAlgorithm*>", -2, "list", 503,
6602  typeid(list<IAlgorithm*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6603  &listlEIAlgorithmmUgR_Dictionary, isa_proxy, 4,
6604  sizeof(list<IAlgorithm*>) );
6605  instance.SetNew(&new_listlEIAlgorithmmUgR);
6606  instance.SetNewArray(&newArray_listlEIAlgorithmmUgR);
6607  instance.SetDelete(&delete_listlEIAlgorithmmUgR);
6608  instance.SetDeleteArray(&deleteArray_listlEIAlgorithmmUgR);
6609  instance.SetDestructor(&destruct_listlEIAlgorithmmUgR);
6610  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< list<IAlgorithm*> >()));
6611  return &instance;
6612  }
6613  // Static variable to force the class initialization
6614  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const list<IAlgorithm*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6615 
6616  // Dictionary for non-ClassDef classes
6617  static TClass *listlEIAlgorithmmUgR_Dictionary() {
6618  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const list<IAlgorithm*>*)0x0)->GetClass();
6619  listlEIAlgorithmmUgR_TClassManip(theClass);
6620  return theClass;
6621  }
6622 
6623  static void listlEIAlgorithmmUgR_TClassManip(TClass* ){
6624  }
6625 
6626 } // end of namespace ROOT
6627 
6628 namespace ROOT {
6629  // Wrappers around operator new
6630  static void *new_listlEIAlgorithmmUgR(void *p) {
6631  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list<IAlgorithm*> : new list<IAlgorithm*>;
6632  }
6633  static void *newArray_listlEIAlgorithmmUgR(Long_t nElements, void *p) {
6634  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list<IAlgorithm*>[nElements] : new list<IAlgorithm*>[nElements];
6635  }
6636  // Wrapper around operator delete
6637  static void delete_listlEIAlgorithmmUgR(void *p) {
6638  delete ((list<IAlgorithm*>*)p);
6639  }
6640  static void deleteArray_listlEIAlgorithmmUgR(void *p) {
6641  delete [] ((list<IAlgorithm*>*)p);
6642  }
6643  static void destruct_listlEIAlgorithmmUgR(void *p) {
6644  typedef list<IAlgorithm*> current_t;
6645  ((current_t*)p)->~current_t();
6646  }
6647 } // end of namespace ROOT for class list<IAlgorithm*>
6648 
6649 namespace {
6650  void TriggerDictionaryInitialization_GaudiPythonDict_Impl() {
6651  static const char* headers[] = {
6652 0 };
6653  static const char* includePaths[] = {
6654 "/builds/gaudi/Gaudi/GaudiPython",
6655 "/builds/gaudi/Gaudi/GaudiPluginService",
6656 "/builds/gaudi/Gaudi/GaudiKernel",
6657 "/builds/gaudi/Gaudi/GaudiUtils",
6658 "/builds/gaudi/Gaudi/GaudiAlg",
6659 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/Python/2.7.13/x86_64-centos7-gcc62-opt/include/python2.7",
6660 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/clhep/2.4.0.1/x86_64-centos7-gcc62-opt/include",
6661 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/rangev3/0.3.0/x86_64-centos7-gcc62-opt/include",
6662 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/AIDA/3.2.1/x86_64-centos7-gcc62-opt/src/cpp",
6663 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/tbb/2018_U1/x86_64-centos7-gcc62-opt/include",
6664 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/ROOT/6.12.06/x86_64-centos7-gcc62-opt/include",
6665 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/Boost/1.66.0/x86_64-centos7-gcc62-opt/include",
6666 "/builds/gaudi/Gaudi/build-gcc62/include",
6667 "/cvmfs/sft.cern.ch/lcg/releases/ROOT/6.12.06-51921/x86_64-centos7-gcc62-opt/include",
6668 "/builds/gaudi/Gaudi/build-gcc62/GaudiPython/",
6669 0
6670  };
6671  static const char* fwdDeclCode = R"DICTFWDDCLS(
6672 #line 1 "GaudiPythonDict dictionary forward declarations' payload"
6673 #pragma clang diagnostic ignored "-Wkeyword-compat"
6674 #pragma clang diagnostic ignored "-Wignored-attributes"
6675 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
6676 extern int __Cling_Autoloading_Map;
6677 class __attribute__((annotate("$clingAutoload$GaudiKernel/IService.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IService;
6678 namespace std{template <typename _Tp> class __attribute__((annotate("$clingAutoload$bits/allocator.h"))) __attribute__((annotate("$clingAutoload$string"))) allocator;
6679 }
6680 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgorithm.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IAlgorithm;
6681 class __attribute__((annotate("$clingAutoload$GaudiKernel/IRegistry.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/AlgDecorators.h"))) IRegistry;
6682 namespace std{template <class _CharT> struct __attribute__((annotate("$clingAutoload$bits/char_traits.h"))) __attribute__((annotate("$clingAutoload$string"))) char_traits;
6683 }
6684 namespace std{template <typename _Arg, typename _Result> struct __attribute__((annotate("$clingAutoload$bits/stl_function.h"))) __attribute__((annotate("$clingAutoload$string"))) unary_function;
6685 }
6686 namespace std{struct __attribute__((annotate("$clingAutoload$typeindex"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) type_index;}
6687 namespace Gaudi{namespace Details{class __attribute__((annotate("$clingAutoload$GaudiKernel/Property.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) PropertyBase;}}
6688 class __attribute__((annotate("$clingAutoload$GaudiKernel/IInterface.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IInterface;
6689 class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgTool.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) IAlgTool;
6690 class __attribute__((annotate("$clingAutoload$GaudiKernel/StatEntity.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Chrono.h"))) StatEntity;
6691 namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiHistoID.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) ID;}
6692 namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IHistogram1D;}
6693 namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IHistogram2D;}
6694 namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IHistogram3D;}
6695 namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IProfile1D;}
6696 namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IProfile2D;}
6697 namespace std{struct __attribute__((annotate(R"ATTRDUMP(pattern@@@std::_Bit_reference*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$bits/stl_bvector.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) _Bit_reference;}
6698 namespace Gaudi{namespace Utils{class __attribute__((annotate("$clingAutoload$GaudiKernel/MapBase.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) MapBase;}}
6699 namespace Gaudi{class __attribute__((annotate("$clingAutoload$GaudiKernel/StringKey.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) StringKey;}
6700 class __attribute__((annotate(R"ATTRDUMP(pattern@@@Chrono*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/ChronoEntity.h"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Chrono.h"))) ChronoEntity;
6701 class __attribute__((annotate(R"ATTRDUMP(pattern@@@Chrono*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Chrono.h"))) Chrono;
6702 class __attribute__((annotate("$clingAutoload$GaudiKernel/ParticleProperty.h"))) ParticleProperty;
6703 namespace Gaudi{struct __attribute__((annotate("$clingAutoload$GaudiKernel/Range.h"))) RangeBase_;}
6704 class __attribute__((annotate("$clingAutoload$GaudiKernel/Stat.h"))) Stat;
6705 namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IAxis;}
6706 namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IBaseHistogram;}
6707 namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IHistogram;}
6708 namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IProfile;}
6709 namespace GaudiPython{struct __attribute__((annotate("$clingAutoload$GaudiPython/Helpers.h"))) Helper;}
6710 class __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h"))) Algorithm;
6711 template <class BASE> class __attribute__((annotate("$clingAutoload$GaudiAlg/GetData.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/AlgDecorators.h"))) GaudiCommon;
6712 
6713 class __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/AlgDecorators.h"))) AlgTool;
6714 class __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiAlgorithm.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/AlgDecorators.h"))) GaudiAlgorithm;
6715 namespace GaudiPython{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiPython::*Decorator*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiPython/AlgDecorators.h"))) AlgDecorator;}
6716 namespace GaudiPython{class __attribute__((annotate("$clingAutoload$GaudiPython/Algorithm.h"))) PyAlgorithm;}
6717 namespace GaudiPython{template <class ALGORITHM> class __attribute__((annotate("$clingAutoload$GaudiPython/Algorithm.h"))) PyAlg;
6718 }
6719 struct __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiHistoAlg.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) GaudiHistoAlg;
6720 struct __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiTupleAlg.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h"))) GaudiTupleAlg;
6721 namespace GaudiPython{class __attribute__((annotate("$clingAutoload$GaudiPython/CallbackStreamBuf.h"))) CallbackStreamBuf;}
6722 namespace Gaudi{namespace Utils{namespace Histos{class __attribute__((annotate("$clingAutoload$GaudiUtils/HistoTableFormat.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) Table;}}}
6723 template <class PBASE> class __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiHistos.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) GaudiHistos;
6724 
6725 class __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiTool.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) GaudiTool;
6726 namespace GaudiPython{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiPython::*Decorator*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) HistoDecorator;}
6727 class __attribute__((annotate("$clingAutoload$GaudiKernel/ContainedObject.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/Printer.h"))) ContainedObject;
6728 namespace GaudiPython{template <class TYPE> struct __attribute__((annotate("$clingAutoload$GaudiPython/Printer.h"))) Printer;
6729 }
6730 class __attribute__((annotate("$clingAutoload$GaudiKernel/DataObject.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/Helpers.h"))) DataObject;
6731 namespace Tuples{class __attribute__((annotate("$clingAutoload$GaudiAlg/Tuple.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h"))) Tuple;}
6732 template <class PBASE> class __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiTuples.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h"))) GaudiTuples;
6733 
6734 class __attribute__((annotate("$clingAutoload$GaudiAlg/ITupleTool.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h"))) ITupleTool;
6735 namespace GaudiPython{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiPython::*Decorator*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h"))) TupleDecorator;}
6736 namespace GaudiPython{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiPython::*Decorator*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h"))) TupleAlgDecorator;}
6737 namespace GaudiPython{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiPython::*Decorator*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h"))) TupleToolDecorator;}
6738 namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h"))) Print;}
6739 namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h"))) Print1D;}
6740 namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h"))) Print2D;}
6741 namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h"))) Print3D;}
6742 namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h"))) Print1DProf;}
6743 namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h"))) Print2DProf;}
6744 namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h"))) PrintTuple;}
6745 namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h"))) PrintStat;}
6746 class __attribute__((annotate("$clingAutoload$GaudiAlg/IErrorTool.h"))) IErrorTool;
6747 class __attribute__((annotate("$clingAutoload$GaudiAlg/IGenericTool.h"))) IGenericTool;
6748 class __attribute__((annotate("$clingAutoload$GaudiAlg/IHistoTool.h"))) IHistoTool;
6749 class __attribute__((annotate("$clingAutoload$GaudiAlg/ISequencerTimerTool.h"))) ISequencerTimerTool;
6750 namespace Gaudi{namespace Utils{class __attribute__((annotate("$clingAutoload$GaudiUtils/Aida2ROOT.h"))) Aida2ROOT;}}
6751 namespace Gaudi{namespace Utils{class __attribute__((annotate("$clingAutoload$GaudiUtils/HistoStats.h"))) HistoStats;}}
6752 namespace Gaudi{namespace Utils{namespace Histos{class __attribute__((annotate("$clingAutoload$GaudiUtils/HistoStrings.h"))) HistoStrings;}}}
6753 namespace Gaudi{class __attribute__((annotate("$clingAutoload$GaudiUtils/IFileCatalog.h"))) IFileCatalog;}
6754 namespace Gaudi{class __attribute__((annotate("$clingAutoload$GaudiUtils/IFileCatalogMgr.h"))) IFileCatalogMgr;}
6755 namespace Gaudi{class __attribute__((annotate("$clingAutoload$GaudiUtils/IIODataManager.h"))) IDataConnection;}
6756 namespace Gaudi{class __attribute__((annotate("$clingAutoload$GaudiUtils/IIODataManager.h"))) IIODataManager;}
6757 namespace __gnu_cxx{struct dummy;}
6758 namespace Histos{typedef GaudiAlg::ID HistoID __attribute__((annotate("$clingAutoload$GaudiAlg/HistoID.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) ;}
6759 namespace GaudiAlg{typedef Histos::HistoID HistoID __attribute__((annotate("$clingAutoload$GaudiAlg/HistoID.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) ;}
6760 namespace Tuples{typedef GaudiAlg::ID TupleID __attribute__((annotate("$clingAutoload$GaudiAlg/TupleID.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) ;}
6761 namespace GaudiAlg{typedef Tuples::TupleID TupleID __attribute__((annotate("$clingAutoload$GaudiAlg/TupleID.h"))) __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) ;}
6762 )DICTFWDDCLS";
6763  static const char* payloadCode = R"DICTPAYLOAD(
6764 #line 1 "GaudiPythonDict dictionary payload"
6765 #ifdef _Instantiations
6766  #undef _Instantiations
6767 #endif
6768 
6769 #ifndef G__VECTOR_HAS_CLASS_ITERATOR
6770  #define G__VECTOR_HAS_CLASS_ITERATOR 1
6771 #endif
6772 #ifndef _Instantiations
6773  #define _Instantiations GaudiPython_Instantiations
6774 #endif
6775 #ifndef _GNU_SOURCE
6776  #define _GNU_SOURCE 1
6777 #endif
6778 #ifndef unix
6779  #define unix 1
6780 #endif
6781 #ifndef f2cFortran
6782  #define f2cFortran 1
6783 #endif
6784 #ifndef linux
6785  #define linux 1
6786 #endif
6787 #ifndef GAUDI_V20_COMPAT
6788  #define GAUDI_V20_COMPAT 1
6789 #endif
6790 #ifndef BOOST_FILESYSTEM_VERSION
6791  #define BOOST_FILESYSTEM_VERSION 3
6792 #endif
6793 #ifndef BOOST_SPIRIT_USE_PHOENIX_V3
6794  #define BOOST_SPIRIT_USE_PHOENIX_V3 1
6795 #endif
6796 #ifndef PACKAGE_NAME
6797  #define PACKAGE_NAME "GaudiPython"
6798 #endif
6799 #ifndef PACKAGE_VERSION
6800  #define PACKAGE_VERSION "v29r5"
6801 #endif
6802 #ifndef AIDA_FOUND
6803  #define AIDA_FOUND 1
6804 #endif
6805 #ifndef CLHEP_FOUND
6806  #define CLHEP_FOUND 1
6807 #endif
6808 #ifndef NDEBUG
6809  #define NDEBUG 1
6810 #endif
6811 
6812 #define _BACKWARD_BACKWARD_WARNING_H
6813 // redefined anyway in features.h by _GNU_SOURCE
6814 #undef _XOPEN_SOURCE
6815 #undef _POSIX_C_SOURCE
6816 
6817 // ============================================================================
6818 // Python must always be the first.
6819 #ifndef __APPLE__
6820 #include "Python.h"
6821 #endif // not __APPLE__
6822 
6823 #include "GaudiKernel/Algorithm.h"
6824 #include "GaudiKernel/Chrono.h"
6825 #include "GaudiKernel/ChronoEntity.h"
6826 #include "GaudiKernel/HashMap.h"
6827 #include "GaudiKernel/Map.h"
6828 #include "GaudiKernel/MapBase.h"
6829 #include "GaudiKernel/ParticleProperty.h"
6830 #include "GaudiKernel/Property.h"
6831 #include "GaudiKernel/Range.h"
6832 #include "GaudiKernel/SerializeSTL.h"
6833 #include "GaudiKernel/Stat.h"
6834 #include "GaudiKernel/StatEntity.h"
6835 #include "GaudiKernel/StringKey.h"
6836 #include "GaudiKernel/VectorMap.h"
6837 
6838 #ifdef _WIN32
6839 #include "GaudiKernel/GaudiHandle.h"
6840 #endif
6841 
6842 #ifdef __ICC
6843 // disable icc remark #177: declared but never referenced
6844 #pragma warning( disable : 177 )
6845 // disable icc warning #1125: function "C::X()" is hidden by "Y::X" -- virtual function override intended?
6846 #pragma warning( disable : 1125 )
6847 #endif
6848 
6849 // Force visibility of the classes
6850 #ifdef __clang__
6851 #pragma clang diagnostic push
6852 #pragma clang diagnostic ignored "-Wkeyword-macro"
6853 #endif
6854 #define class class GAUDI_API
6855 #ifdef __clang__
6856 #pragma clang diagnostic pop
6857 #endif
6858 #ifdef AIDA_FOUND
6859 #ifdef _WIN32
6860 #include "AIDA/IAnnotation.h"
6861 #endif // _WIN32
6862 #include "AIDA/IAxis.h"
6863 #include "AIDA/IHistogram.h"
6864 #include "AIDA/IHistogram1D.h"
6865 #include "AIDA/IHistogram2D.h"
6866 #include "AIDA/IHistogram3D.h"
6867 #include "AIDA/IProfile1D.h"
6868 #include "AIDA/IProfile2D.h"
6869 #endif // AIDA_FOUND
6870 #undef class
6871 
6872 #include "GaudiPython/Helpers.h"
6873 
6874 #include "GaudiPython/AlgDecorators.h"
6875 #include "GaudiPython/Algorithm.h"
6876 #include "GaudiPython/CallbackStreamBuf.h"
6877 #include "GaudiPython/GaudiPython.h"
6878 #ifdef AIDA_FOUND
6879 #include "GaudiPython/HistoDecorator.h"
6880 #endif // AIDA_FOUND
6881 #include "GaudiPython/Interface.h"
6882 #include "GaudiPython/Printer.h"
6883 #include "GaudiPython/Vector.h"
6884 #ifdef CLHEP_FOUND
6885 #include "GaudiPython/TupleDecorator.h"
6886 #endif // CLHEP_FOUND
6887 
6888 #ifdef AIDA_FOUND
6889 #include "GaudiAlg/GaudiHistoAlg.h"
6890 #include "GaudiAlg/GaudiTupleAlg.h"
6891 #include "GaudiAlg/Print.h"
6892 // Added to avoid warnings about inlined functions never implemented.
6893 #include "GaudiAlg/GaudiHistos.icpp"
6894 #endif // AIDA_FOUND
6895 #include "GaudiAlg/GaudiAlgorithm.h"
6896 #include "GaudiAlg/GaudiCommon.h"
6897 #include "GaudiAlg/GaudiHistoID.h"
6898 #include "GaudiAlg/IErrorTool.h"
6899 #include "GaudiAlg/IGenericTool.h"
6900 #include "GaudiAlg/IHistoTool.h"
6901 #include "GaudiAlg/ISequencerTimerTool.h"
6902 #include "GaudiAlg/ITupleTool.h"
6903 #include "GaudiAlg/Tuple.h"
6904 
6905 #ifdef AIDA_FOUND
6906 #include "GaudiUtils/Aida2ROOT.h"
6907 #include "GaudiUtils/HistoDump.h"
6908 #include "GaudiUtils/HistoStats.h"
6909 #include "GaudiUtils/HistoStrings.h"
6910 #endif // AIDA_FOUND
6911 #include "GaudiUtils/IFileCatalog.h"
6912 #include "GaudiUtils/IFileCatalogMgr.h"
6913 #include "GaudiUtils/IIODataManager.h"
6914 #include "GaudiUtils/QuasiRandom.h"
6915 
6916 #include <iostream>
6917 #include <istream>
6918 #include <sstream>
6919 
6920 template class std::basic_stringstream<char>;
6921 
6922 // needed to find operator<< implemented in GaudiUtils.
6923 using namespace GaudiUtils;
6924 
6925 namespace GaudiPython
6926 {
6927 
6928  template <class TYPE>
6929  struct _Property {
6930  TYPE m_type;
6931  Gaudi::Property<TYPE> m_prop;
6932  Gaudi::Property<TYPE&> m_ref;
6933  // constructor
6934  _Property() : m_type(), m_prop(), m_ref( "", m_type ) {}
6935  //
6936  };
6937 
6938  //--- Template instantiations
6939  struct __Instantiations {
6940  std::vector<Gaudi::Details::PropertyBase*> i0;
6941  std::vector<const Gaudi::Details::PropertyBase*> i00;
6942  std::vector<IRegistry*> i00000;
6943 
6944  std::allocator<IRegistry*> a0;
6945  std::allocator<IAlgorithm*> a1;
6946  std::allocator<IService*> a2;
6947 
6948  std::list<IAlgorithm*> i01;
6949  std::list<IService*> i02;
6950 
6951  std::vector<IService*> i05_1;
6952  std::vector<IAlgTool*> i05_2;
6953  std::vector<const StatEntity*> i05_3;
6954  std::vector<GaudiAlg::ID> i05_4;
6955 #ifdef AIDA_FOUND
6956  std::vector<AIDA::IHistogram1D*> i05_5;
6957  std::vector<AIDA::IHistogram2D*> i05_6;
6958  std::vector<AIDA::IHistogram3D*> i05_7;
6959  std::vector<AIDA::IProfile1D*> i05_8;
6960  std::vector<AIDA::IProfile2D*> i05_9;
6961 #endif // AIDA_FOUND
6962 
6963  // Gaudi::IIODataManager *gu_i1000;
6964 
6965  GaudiUtils::VectorMap<int, double> i034;
6966 
6967  GaudiPython::PyAlg<GaudiAlgorithm> _alg0;
6968 #ifdef AIDA_FOUND
6969  GaudiPython::PyAlg<GaudiHistoAlg> _alg1;
6970  GaudiPython::PyAlg<GaudiTupleAlg> _alg2;
6971 #endif // AIDA_FOUND
6972 
6973  GaudiPython::Matrix _mtrx;
6974  GaudiPython::Vector _vctr;
6975  std::vector<std::vector<double>> _vct1;
6976 
6977  // primitives:
6978  _Property<bool> pp_01;
6979  _Property<char> pp_02;
6980  _Property<signed char> pp_03;
6981  _Property<unsigned char> pp_04;
6982  _Property<short> pp_05;
6983  _Property<unsigned short> pp_06;
6984  _Property<int> pp_07;
6985  _Property<unsigned int> pp_08;
6986  _Property<long> pp_09;
6987  _Property<unsigned long> pp_10;
6988  _Property<long long> pp_11;
6989  _Property<unsigned long long> pp_12;
6990  _Property<float> pp_13;
6991  _Property<double> pp_14;
6992  _Property<long double> pp_15;
6993  _Property<std::string> pp_16;
6994 
6995  // vectors of primitives
6996  _Property<std::vector<bool>> vp_01;
6997  _Property<std::vector<char>> vp_02;
6998  _Property<std::vector<signed char>> vp_03;
6999  _Property<std::vector<unsigned char>> vp_04;
7000  _Property<std::vector<short>> vp_05;
7001  _Property<std::vector<unsigned short>> vp_06;
7002  _Property<std::vector<int>> vp_07;
7003  _Property<std::vector<unsigned int>> vp_08;
7004  _Property<std::vector<long>> vp_09;
7005  _Property<std::vector<unsigned long>> vp_10;
7006  _Property<std::vector<long long>> vp_11;
7007  _Property<std::vector<unsigned long long>> vp_12;
7008  _Property<std::vector<float>> vp_13;
7009  _Property<std::vector<double>> vp_14;
7010  _Property<std::vector<long double>> vp_15;
7011  _Property<std::vector<std::string>> vp_16;
7012 
7013  // some extended types
7014  _Property<std::pair<int, int>> ep_01;
7015  _Property<std::pair<double, double>> ep_02;
7016  _Property<std::vector<std::pair<double, double>>> ep_04;
7017  _Property<std::vector<std::vector<std::string>>> ep_05;
7018  _Property<std::vector<std::vector<double>>> ep_06;
7019  _Property<std::map<int, double>> ep_07;
7020  _Property<std::map<std::string, std::string>> ep_08;
7021  _Property<std::map<std::string, int>> ep_09;
7022  _Property<std::map<std::string, double>> ep_10;
7023  _Property<std::map<std::string, std::vector<std::string>>> ep_11;
7024  _Property<std::map<std::string, std::vector<int>>> ep_12;
7025  _Property<std::map<std::string, std::vector<double>>> ep_13;
7026 
7027  __Instantiations();
7028  ~__Instantiations();
7029  };
7030 
7031 } // end of namespace GaudiPython
7032 
7033 namespace __gnu_cxx
7034 {
7035  struct dummy {
7036  };
7037 } // hack to please CINT
7038 
7039 #ifdef _WIN32
7040 #pragma warning( disable : 4345 )
7041 #pragma warning( disable : 4624 )
7042 #endif
7043 
7044 #ifdef __ICC
7045 // disable icc warning #191: type qualifier is meaningless on cast type
7046 // ... a lot of noise produced by the dictionary
7047 #pragma warning( disable : 191 )
7048 #endif
7049 
7050 // ============================================================================
7051 // The END
7052 // ============================================================================
7053 
7054 #undef _BACKWARD_BACKWARD_WARNING_H
7055 )DICTPAYLOAD";
7056  static const char* classesHeaders[]={
7057 "", payloadCode, "@",
7058 "AIDA::IAxis", payloadCode, "@",
7059 "AIDA::IAxis::(anonymous)", payloadCode, "@",
7060 "AIDA::IBaseHistogram", payloadCode, "@",
7061 "AIDA::IHistogram", payloadCode, "@",
7062 "AIDA::IHistogram1D", payloadCode, "@",
7063 "AIDA::IHistogram2D", payloadCode, "@",
7064 "AIDA::IHistogram3D", payloadCode, "@",
7065 "AIDA::IProfile", payloadCode, "@",
7066 "AIDA::IProfile1D", payloadCode, "@",
7067 "AIDA::IProfile2D", payloadCode, "@",
7068 "Chrono", payloadCode, "@",
7069 "ChronoEntity", payloadCode, "@",
7070 "Gaudi::IDataConnection", payloadCode, "@",
7071 "Gaudi::IFileCatalog", payloadCode, "@",
7072 "Gaudi::IFileCatalogMgr", payloadCode, "@",
7073 "Gaudi::IIODataManager", payloadCode, "@",
7074 "Gaudi::RangeBase_", payloadCode, "@",
7075 "Gaudi::StringKey", payloadCode, "@",
7076 "Gaudi::Utils::Aida2ROOT", payloadCode, "@",
7077 "Gaudi::Utils::HistoStats", payloadCode, "@",
7078 "Gaudi::Utils::Histos::Formats::Format", payloadCode, "@",
7079 "Gaudi::Utils::Histos::Formats::format", payloadCode, "@",
7080 "Gaudi::Utils::Histos::Formats::header", payloadCode, "@",
7081 "Gaudi::Utils::Histos::HistoStrings", payloadCode, "@",
7082 "Gaudi::Utils::Histos::Table", payloadCode, "@",
7083 "Gaudi::Utils::Histos::format", payloadCode, "@",
7084 "Gaudi::Utils::Histos::histoDump", payloadCode, "@",
7085 "Gaudi::Utils::Histos::path", payloadCode, "@",
7086 "Gaudi::Utils::MapBase", payloadCode, "@",
7087 "Gaudi::Utils::QuasiRandom::mix", payloadCode, "@",
7088 "Gaudi::Utils::QuasiRandom::mix32", payloadCode, "@",
7089 "Gaudi::Utils::QuasiRandom::mix64", payloadCode, "@",
7090 "Gaudi::Utils::QuasiRandom::mixString", payloadCode, "@",
7091 "Gaudi::Utils::hasProperty", payloadCode, "@",
7092 "GaudiAlg::HistoID", payloadCode, "@",
7093 "GaudiAlg::ID", payloadCode, "@",
7094 "GaudiAlg::Print", payloadCode, "@",
7095 "GaudiAlg::Print1D", payloadCode, "@",
7096 "GaudiAlg::Print1DProf", payloadCode, "@",
7097 "GaudiAlg::Print2D", payloadCode, "@",
7098 "GaudiAlg::Print2DProf", payloadCode, "@",
7099 "GaudiAlg::Print3D", payloadCode, "@",
7100 "GaudiAlg::PrintStat", payloadCode, "@",
7101 "GaudiAlg::PrintTuple", payloadCode, "@",
7102 "GaudiAlg::TupleID", payloadCode, "@",
7103 "GaudiAlgorithm", payloadCode, "@",
7104 "GaudiCommon<AlgTool>", payloadCode, "@",
7105 "GaudiCommon<Algorithm>", payloadCode, "@",
7106 "GaudiHistos<GaudiAlgorithm>", payloadCode, "@",
7107 "GaudiHistos<GaudiTool>", payloadCode, "@",
7108 "GaudiPython::AlgDecorator", payloadCode, "@",
7109 "GaudiPython::CallbackStreamBuf", payloadCode, "@",
7110 "GaudiPython::Helper", payloadCode, "@",
7111 "GaudiPython::HistoDecorator", payloadCode, "@",
7112 "GaudiPython::Printer<ContainedObject>", payloadCode, "@",
7113 "GaudiPython::Printer<DataObject>", payloadCode, "@",
7114 "GaudiPython::PyAlg<GaudiAlgorithm>", payloadCode, "@",
7115 "GaudiPython::PyAlg<GaudiHistoAlg>", payloadCode, "@",
7116 "GaudiPython::PyAlg<GaudiTupleAlg>", payloadCode, "@",
7117 "GaudiPython::PyAlgorithm", payloadCode, "@",
7118 "GaudiPython::TupleAlgDecorator", payloadCode, "@",
7119 "GaudiPython::TupleDecorator", payloadCode, "@",
7120 "GaudiPython::TupleToolDecorator", payloadCode, "@",
7121 "GaudiTuples<GaudiHistoAlg>", payloadCode, "@",
7122 "IErrorTool", payloadCode, "@",
7123 "IGenericTool", payloadCode, "@",
7124 "IHistoTool", payloadCode, "@",
7125 "ISequencerTimerTool", payloadCode, "@",
7126 "ITupleTool", payloadCode, "@",
7127 "ParticleProperty", payloadCode, "@",
7128 "Stat", payloadCode, "@",
7129 "StatEntity", payloadCode, "@",
7130 "Tuples::Tuple", payloadCode, "@",
7131 "_Bit_reference", "@",
7132 "__gnu_cxx::dummy", payloadCode, "@",
7133 "std::ostream", payloadCode, "@",
7134 "unary_function<Gaudi::Details::PropertyBase&,void>", payloadCode, "@",
7135 nullptr};
7136 
7137  static bool isInitialized = false;
7138  if (!isInitialized) {
7139  TROOT::RegisterModule("GaudiPythonDict",
7140  headers, includePaths, payloadCode, fwdDeclCode,
7141  TriggerDictionaryInitialization_GaudiPythonDict_Impl, {}, classesHeaders);
7142  isInitialized = true;
7143  }
7144  }
7145  static struct DictInit {
7146  DictInit() {
7147  TriggerDictionaryInitialization_GaudiPythonDict_Impl();
7148  }
7149  } __TheDictionaryInitializer;
7150 }
7151 void TriggerDictionaryInitialization_GaudiPythonDict() {
7152  TriggerDictionaryInitialization_GaudiPythonDict_Impl();
7153 }
TriggerDictionaryInitialization_GaudiPythonDict
void TriggerDictionaryInitialization_GaudiPythonDict()
Definition: GaudiPythonDict.cpp:7151
GaudiPython::TupleDecorator
Simple class which performs the decoration of the standard N-Tuple.
Definition: TupleDecorator.h:46
Gaudi::Utils::Aida2ROOT
Accessor to underlying ROOT-representation of transient histograms The actual code is imported from B...
Definition: Aida2ROOT.h:60
GaudiPython::TupleAlgDecorator
Simple class to perform the "decoration" of Tuples in Python/ROOT.
Definition: TupleDecorator.h:269
ChronoEntity
a small helper class for implementation of ChronoStatSvc service, It also could be used as some local...
Definition: ChronoEntity.h:21
Stat
Small wrapper class for easy manipulation with generic counters and IStatSvc&ICounterSvc interface...
Definition: Stat.h:46
ParticleProperty
A trivial class to hold information about a single particle properties.
Definition: ParticleProperty.h:18
GaudiAlg::Print1DProf
collection of useful utilities to print IProfile1D (currently used for implementation of class GaudiH...
Definition: Print.h:112
std
STL namespace.
std::allocator
STL class.
Gaudi::RangeBase_
helper class to simplify the dealing with ranges in Python
Definition: Range.h:82
GaudiPython::TupleToolDecorator
Simple class to perform the "decoration" of Tuples in Python/ROOT.
Definition: TupleDecorator.h:312
Chrono
A small utility class for chronometry of user codes.
Definition: Chrono.h:25
GaudiAlg::Print1D
collection of useful utilities to print IHistogram1D (currently used for implementation of class Gaud...
Definition: Print.h:65
GaudiAlg::Print2D
collection of useful utilities to print IHistogram1D (currently used for implementation of class Gaud...
Definition: Print.h:80
GaudiAlg::Print3D
collection of useful utilities to print IHistogram1D (currently used for implementation of class Gaud...
Definition: Print.h:96
std::map
STL class.
Gaudi::StringKey
The helper class to represent the efficient "key" for access.
Definition: StringKey.h:35
IGenericTool
General purpose interface class for tools that "do something".
Definition: IGenericTool.h:13
Tuples::Tuple
A simple wrapper class over standard Gaudi NTuple::Tuple facility.
Definition: Tuple.h:117
GaudiAlg::PrintStat
collection of useful utilities to print StatEntity (currently used for implementation of class GaudiA...
Definition: Print.h:162
GaudiAlgorithm
The useful base class for data processing algorithms.
Definition: GaudiAlgorithm.h:94
GaudiPython::PyAlg
general class to embed the existing algorithm/base class into the python
Definition: Algorithm.h:62
Gaudi::Utils::Histos::Table
Simple class for the customizeble printout of the histogram tables.
Definition: HistoTableFormat.h:381
Genfun::GaudiMathImplementation::ROOT::R__UseDummy
R__UseDummy(_R__UNIQUE_DICT_(Init))
GaudiAlg::Print2DProf
collection of useful utilities to print IProfile2D (currently used for implementation of class GaudiH...
Definition: Print.h:128
Gaudi::IFileCatalog
File catalog interface.
Definition: IFileCatalog.h:25
std::vector
STL class.
Gaudi::IDataConnection
ABC describing basic data connection.
Definition: IIODataManager.h:25
Gaudi::Utils::Histos::HistoStrings
Helper class to produce "good" dictionaries.
Definition: HistoStrings.h:52
GaudiPython::PyAlgorithm
Python Algorithm base class.
Definition: Algorithm.h:32
ROOT::GenerateInitInstance
TGenericClassInfo * GenerateInitInstance(const ::__gnu_cxx::dummy *)
Definition: GaudiPythonDict.cpp:3869
ISequencerTimerTool
Implements the time measurement inside a sequencer.
Definition: ISequencerTimerTool.h:14
Gaudi::Utils::HistoStats
The collection of trivial functions to access the statistical information for the histograms...
Definition: HistoStats.h:32
Gaudi::IFileCatalogMgr
File catalog manager.
Definition: IFileCatalogMgr.h:27
StatEntity
The basic counter used for Monitoring purposes.
Definition: StatEntity.h:65
GaudiAlg::PrintTuple
collection of useful utilities to print INTuple object (currently used for implementation of class Ga...
Definition: Print.h:145
Gaudi::Utils::MapBase
Helper base-class to allow the generic Python-decoration for all "map-like" classes in Gaudi...
Definition: MapBase.h:44
GaudiPython::HistoDecorator
Simple decorator class to allow to reuse the functionality of GaudiHistos<TYPE> class in pythin...
Definition: HistoDecorator.h:26
GaudiAlg::Print
collection of useful utilities to print IHistogram1D (currently used for implementation of class Gaud...
Definition: Print.h:52
GaudiAlg::ID
ID class for Histogram and Ntuples.
Definition: GaudiHistoID.h:44
IHistoTool
An abstract interface for "histogramming tool".
Definition: IHistoTool.h:31