# 1 "/tmp/18jMST_cint.cxx"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/tmp/18jMST_cint.cxx"
# 1 "/tmp/rootcint_hxzv6S.h" 1
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 1
// @(#)root/base:$Id: TObject.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TObject                                                              //
//                                                                      //
// Mother of all ROOT objects.                                          //
//                                                                      //
// The TObject class provides default behaviour and protocol for all    //
// objects in the ROOT system. It provides protocol for object I/O,     //
// error handling, sorting, inspection, printing, drawing, etc.         //
// Every object which inherits from TObject can be stored in the        //
// ROOT collection classes.                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 1
/* @(#)root/base:$Id: Rtypes.h 43708 2012-04-12 10:19:00Z axel $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Rtypes                                                               //
//                                                                      //
// Basic types used by ROOT.                                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////



# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/RConfig.h" 1
/* @(#)root/base:$Id: RConfig.h 43709 2012-04-12 11:04:01Z rdm $ */

/*************************************************************************
 * Copyright (C) 1995-2002, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




/*************************************************************************
 *                                                                       *
 * RConfig                                                               *
 *                                                                       *
 * Defines used by ROOT.                                                 *
 *                                                                       *
 *************************************************************************/


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/RVersion.h" 1



/* Version information automatically generated by installer. */

/*
 * These macros can be used in the following way:
 *
 *    #if ROOT_VERSION_CODE >= ROOT_VERSION(2,23,4)
 *       #include <newheader.h>
 *    #else
 *       #include <oldheader.h>
 *    #endif
 *
*/
# 24 "/nfs/RAID/opt/root/v5.34.01_sl61/include/RConfig.h" 2



/*---- new C++ features ------------------------------------------------------*/



/*---- machines --------------------------------------------------------------*/
# 181 "/nfs/RAID/opt/root/v5.34.01_sl61/include/RConfig.h"
# 1 "/usr/include/features.h" 1 3 4
/* Copyright (C) 1991-1993,1995-2007,2009,2010 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */




/* These are defined by the user (or the compiler)
   to specify the desired environment:

   __STRICT_ANSI__	ISO Standard C.
   _ISOC99_SOURCE	Extensions to ISO C89 from ISO C99.
   _POSIX_SOURCE	IEEE Std 1003.1.
   _POSIX_C_SOURCE	If ==1, like _POSIX_SOURCE; if >=2 add IEEE Std 1003.2;
			if >=199309L, add IEEE Std 1003.1b-1993;
			if >=199506L, add IEEE Std 1003.1c-1995;
			if >=200112L, all of IEEE 1003.1-2004
			if >=200809L, all of IEEE 1003.1-2008
   _XOPEN_SOURCE	Includes POSIX and XPG things.  Set to 500 if
			Single Unix conformance is wanted, to 600 for the
			sixth revision, to 700 for the seventh revision.
   _XOPEN_SOURCE_EXTENDED XPG things and X/Open Unix extensions.
   _LARGEFILE_SOURCE	Some more functions for correct standard I/O.
   _LARGEFILE64_SOURCE	Additional functionality from LFS for large files.
   _FILE_OFFSET_BITS=N	Select default filesystem interface.
   _BSD_SOURCE		ISO C, POSIX, and 4.3BSD things.
   _SVID_SOURCE		ISO C, POSIX, and SVID things.
   _ATFILE_SOURCE	Additional *at interfaces.
   _GNU_SOURCE		All of the above, plus GNU extensions.
   _REENTRANT		Select additionally reentrant object.
   _THREAD_SAFE		Same as _REENTRANT, often used by other systems.
   _FORTIFY_SOURCE	If set to numeric value > 0 additional security
			measures are defined, according to level.

   The `-ansi' switch to the GNU C compiler defines __STRICT_ANSI__.
   If none of these are defined, the default is to have _SVID_SOURCE,
   _BSD_SOURCE, and _POSIX_SOURCE set to one and _POSIX_C_SOURCE set to
   200112L.  If more than one of these are defined, they accumulate.
   For example __STRICT_ANSI__, _POSIX_SOURCE and _POSIX_C_SOURCE
   together give you ISO C, 1003.1, and 1003.2, but nothing else.

   These are defined by this file and are used by the
   header files to decide what to declare or define:

   __USE_ISOC99		Define ISO C99 things.
   __USE_ISOC95		Define ISO C90 AMD1 (C95) things.
   __USE_POSIX		Define IEEE Std 1003.1 things.
   __USE_POSIX2		Define IEEE Std 1003.2 things.
   __USE_POSIX199309	Define IEEE Std 1003.1, and .1b things.
   __USE_POSIX199506	Define IEEE Std 1003.1, .1b, .1c and .1i things.
   __USE_XOPEN		Define XPG things.
   __USE_XOPEN_EXTENDED	Define X/Open Unix things.
   __USE_UNIX98		Define Single Unix V2 things.
   __USE_XOPEN2K        Define XPG6 things.
   __USE_XOPEN2KXSI     Define XPG6 XSI things.
   __USE_XOPEN2K8XSI    Define XPG7 XSI things.
   __USE_LARGEFILE	Define correct standard I/O things.
   __USE_LARGEFILE64	Define LFS things with separate names.
   __USE_FILE_OFFSET64	Define 64bit interface as default.
   __USE_BSD		Define 4.3BSD things.
   __USE_SVID		Define SVID things.
   __USE_MISC		Define things common to BSD and System V Unix.
   __USE_ATFILE		Define *at interfaces and AT_* constants for them.
   __USE_GNU		Define GNU extensions.
   __USE_REENTRANT	Define reentrant/thread-safe *_r functions.
   __USE_FORTIFY_LEVEL	Additional security measures used, according to level.
   __FAVOR_BSD		Favor 4.3BSD things in cases of conflict.

   The macros `__GNU_LIBRARY__', `__GLIBC__', and `__GLIBC_MINOR__' are
   defined by this file unconditionally.  `__GNU_LIBRARY__' is provided
   only for compatibility.  All new code should use the other symbols
   to test for features.

   All macros listed above as possibly being defined by this file are
   explicitly undefined if they are not explicitly defined.
   Feature-test macros that are not defined by the user or compiler
   but are implied by the other feature-test macros defined (or by the
   lack of any definitions) are defined by the file.  */


/* Undefine everything, so we get a clean slate.  */
# 122 "/usr/include/features.h" 3 4
/* Suppress kernel-name space pollution unless user expressedly asks
   for it.  */




/* Always use ISO C things.  */


/* Convenience macros to test the versions of glibc and gcc.
   Use them like this:
   #if __GNUC_PREREQ (2,8)
   ... code requiring gcc 2.8 or later ...
   #endif
   Note - they won't work for gcc1 or glibc1, since the _MINOR macros
   were not defined then.  */
# 146 "/usr/include/features.h" 3 4
/* If _BSD_SOURCE was defined by the user, favor BSD over POSIX.  */






/* If _GNU_SOURCE was defined by the user, turn on all the other features.  */
# 177 "/usr/include/features.h" 3 4
/* If nothing (other than _GNU_SOURCE) is defined,
   define _BSD_SOURCE and _SVID_SOURCE.  */







/* This is to enable the ISO C99 extension.  Also recognize the old macro
   which was used prior to the standard acceptance.  This macro will
   eventually go away and the features enabled by default once the ISO C99
   standard is widely adopted.  */





/* This is to enable the ISO C90 Amendment 1:1995 extension.  */





/* If none of the ANSI/POSIX macros are defined, use POSIX.1 and POSIX.2
   (and IEEE Std 1003.1b-1993 unless _XOPEN_SOURCE is defined).  */
# 326 "/usr/include/features.h" 3 4
/* We do support the IEC 559 math functionality, real and complex.  */



/* wchar_t uses ISO 10646-1 (2nd ed., published 2000-09-15) / Unicode 3.1.  */


/* This macro indicates that the installed library is the GNU C Library.
   For historic reasons the value now is 6 and this will stay from now
   on.  The use of this variable is deprecated.  Use __GLIBC__ and
   __GLIBC_MINOR__ now (see below) when you want to test for a specific
   GNU C library version and use the values in <gnu/lib-names.h> to get
   the sonames of the shared libraries.  */



/* Major and minor version number of the GNU C library package.  Use
   these macros to test for features in specific releases.  */






/* Decide whether a compiler supports the long long datatypes.  */







/* This is here only because every header file already includes this one.  */


# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/sys/cdefs.h" 1 3 4
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/



/* Using external C/C++ preprocessor with -p or +P option */

# 1 "/usr/include/sys/cdefs.h" 1 3 4
/* Copyright (C) 1992-2001, 2002, 2004, 2005, 2006, 2007, 2009
   Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */




/* We are almost always included from features.h. */




/* The GNU libc does not support any K&R compilers or the traditional mode
   of ISO C compilers anymore.  Check for some of the combinations not
   anymore supported.  */




/* Some user header file might have defined this before.  */





/* GCC can always grok prototypes.  For C++ programs we add throw()
   to help it optimize the function calls.  But this works only with
   gcc 2.8.x and egcs.  For gcc 3.2 and up we even mark C functions
   as non-throwing using a function attribute since programs can use
   the -fexceptions options for C code as well.  */
# 72 "/usr/include/sys/cdefs.h" 3 4
/* These two macros are not used in glibc anymore.  They are kept here
   only because some other projects expect the macros to be defined.  */



/* For these things, GCC behaves the ANSI way normally,
   and the non-ANSI way under -traditional.  */




/* This is not a typedef so `const __ptr_t' does the right thing.  */




/* C++ needs to know that types and declarations are C, not C++.  */
# 98 "/usr/include/sys/cdefs.h" 3 4
/* The standard library needs the functions from the ISO C90 standard
   in the std namespace.  At the same time we want to be safe for
   future changes and we include the ISO C99 code in the non-standard
   namespace __c99.  The C++ wrapper header take case of adding the
   definitions to the global namespace.  */
# 111 "/usr/include/sys/cdefs.h" 3 4
/* For compatibility we do not add the declarations into any
   namespace.  They will end up in the global namespace which is what
   old code expects.  */
# 123 "/usr/include/sys/cdefs.h" 3 4
/* Support for bounded pointers.  */







/* Fortify support.  */
# 150 "/usr/include/sys/cdefs.h" 3 4
/* Support for flexible arrays.  */

/* GCC 2.97 supports C99 flexible array members.  */
# 168 "/usr/include/sys/cdefs.h" 3 4
/* __asm__ ("xyz") is used throughout the headers to rename functions
   at the assembly language level.  This is wrapped by the __REDIRECT
   macro, in order to support compilers that can do this some other
   way.  When compilers don't support asm-names at all, we have to do
   preprocessor tricks instead (which don't have exactly the right
   semantics, but it's the best we can do).

   Example:
   int __REDIRECT(setpgrp, (__pid_t pid, __pid_t pgrp), setpgid); */
# 191 "/usr/include/sys/cdefs.h" 3 4
/*
#elif __SOME_OTHER_COMPILER__

# define __REDIRECT(name, proto, alias) name proto; 	_Pragma("let " #name " = " #alias)
)
*/


/* GCC has various useful declarations that can be made with the
   `__attribute__' syntax.  All of the ways we use this do fine if
   they are omitted for compilers that don't understand it. */




/* At some point during the gcc 2.96 development the `malloc' attribute
   for functions was introduced.  We don't want to use it unconditionally
   (although this would be possible) since it generates warnings.  */






/* At some point during the gcc 2.96 development the `pure' attribute
   for functions was introduced.  We don't want to use it unconditionally
   (although this would be possible) since it generates warnings.  */






/* At some point during the gcc 3.1 development the `used' attribute
   for functions was introduced.  We don't want to use it unconditionally
   (although this would be possible) since it generates warnings.  */
# 235 "/usr/include/sys/cdefs.h" 3 4
/* gcc allows marking deprecated functions.  */






/* At some point during the gcc 2.8 development the `format_arg' attribute
   for functions was introduced.  We don't want to use it unconditionally
   (although this would be possible) since it generates warnings.
   If several `format_arg' attributes are given for the same function, in
   gcc-3.0 and older, all but the last one are ignored.  In newer gccs,
   all designated arguments are considered.  */






/* At some point during the gcc 2.97 development the `strfmon' format
   attribute for functions was introduced.  We don't want to use it
   unconditionally (although this would be possible) since it
   generates warnings.  */







/* The nonull function attribute allows to mark pointer parameters which
   must not be NULL.  */






/* If fortification mode, we warn about unused results of certain
   function calls which can lead to problems.  */
# 288 "/usr/include/sys/cdefs.h" 3 4
/* Forces a function to be always inlined.  */






/* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99
   inline semantics, unless -fgnu89-inline is used.  */
# 324 "/usr/include/sys/cdefs.h" 3 4
/* GCC 4.3 and above allow passing all anonymous arguments of an
   __extern_always_inline function to some other vararg function.  */
# 334 "/usr/include/sys/cdefs.h" 3 4
/* It is possible to compile containing GCC extensions even if GCC is
   run in pedantic mode if the uses are carefully marked using the
   `__extension__' keyword.  But this is not generally available before
   version 2.8.  */




/* __restrict is known in EGCS 1.2 and above. */




/* ISO C99 also allows to declare arrays as non-overlapping.  The syntax is
     array_name[restrict]
   GCC 3.1 supports this.  */
# 365 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
/* Determine the wordsize from the preprocessor defines.  */
# 366 "/usr/include/sys/cdefs.h" 2 3 4
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/sys/cdefs.h" 2 3 4
# 362 "/usr/include/features.h" 2 3 4


/* If we don't have __REDIRECT, prototypes will be missing if
   __USE_FILE_OFFSET64 but not __USE_LARGEFILE[64]. */







/* Decide whether we can define 'extern inline' functions in headers.  */







/* This is here only because every header file already includes this one.
   Get the definitions of all the appropriate `__stub_FUNCTION' symbols.
   <gnu/stubs.h> contains `#define __stub_FUNCTION' when FUNCTION is a stub
   that will always return failure (and set errno to ENOSYS).  */
# 1 "/usr/include/gnu/stubs.h" 1 3 4
/* This file selects the right generated file of `__stub_FUNCTION' macros
   based on the architecture being compiled for.  */

# 1 "/usr/include/bits/wordsize.h" 1 3 4
/* Determine the wordsize from the preprocessor defines.  */
# 5 "/usr/include/gnu/stubs.h" 2 3 4




# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
/* This file is automatically generated.
   It defines a symbol `__stub_FUNCTION' for each function
   in the C library which is a stub, meaning it will fail
   every time called, usually setting errno to ENOSYS.  */
# 10 "/usr/include/gnu/stubs.h" 2 3 4
# 386 "/usr/include/features.h" 2 3 4
# 182 "/nfs/RAID/opt/root/v5.34.01_sl61/include/RConfig.h" 2
# 251 "/nfs/RAID/opt/root/v5.34.01_sl61/include/RConfig.h"
/*
    Note, that there are really 3 APIs:

    mips, mipsel:
      O32 ABI, ILP32, "long long" in a "aligned" even-odd register
      pair, 4 argument registers

    mipsn32, mipsn32el
      N32 ABI, ILP32, but with 64 bit wide registers, and "long long"
      in a single register, 8 argument registers

    mips64, mips64el
      N64 ABI, LP64, 8 argument registers

    where O32, N32, and N64 are the ABI names.  ILP32 means that
    (I)int, (L)long, (P)pointer are 32bit long. LP64 means that
    long and pointer are 64bit long.  "el" denotes if the ABI is
    little endian.

    N32 is different from 032, in the calling convention.  Arguments
    passed as 64bit (long long) reference, and there are 8 of those.
    O32 is the one closest to "normal" GNU/Linux on i386.

    It's a bit more complex. MIPS spans probably the largest
    performance range of any CPU family, from a 32bit 20 MHz
    Microcontroller (made by Microchip) up to a 64bit monster with
    over 5000 CPUs (made by SiCortex).  Obviously, only the 64bit
    CPUs can run 64bit code, but 32bit code runs on all of them.

    The use cases for the different ABIs are:
    - O32: Most compatible, runs everywhere
    - N32: Best performance on 64 bit if a large address space isn't
           needed.  It is faster than O32 due to improved calling
           conventions, and it is faster than N64 due to reduced
           pointer size.
    - N64: Huge address space.

    Currently (end 2007) Debian GNU/Linux only supports O32

    Thanks to Thiemo Seufer <ths@networkno.de> of Debian
*/
# 431 "/nfs/RAID/opt/root/v5.34.01_sl61/include/RConfig.h"
/* allows symbols to be hidden from the shared library export symbol table */
/* use typically on file statics and private methods */
# 514 "/nfs/RAID/opt/root/v5.34.01_sl61/include/RConfig.h"
/*--- memory and object statistics -------------------------------------------*/

/* #define R__NOSTATS */

/*--- cpp --------------------------------------------------------------------*/


    /* symbol concatenation operator */




    /* stringizing */
# 539 "/nfs/RAID/opt/root/v5.34.01_sl61/include/RConfig.h"
/* produce an identifier that is almost unique inside a file */
# 549 "/nfs/RAID/opt/root/v5.34.01_sl61/include/RConfig.h"
    /* Currently CINT does not really mind to have duplicates and     */
    /* does not work correctly as far as merging tokens is concerned. */



/*---- misc ------------------------------------------------------------------*/
# 25 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/DllImport.h" 1
/* @(#)root/base:$Id: DllImport.h 22729 2008-03-19 10:20:10Z pcanal $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

/*
  This include file defines the DllImport macro
  to build DLLs under Windows OS.

  They are defined as dummy for UNIX's
*/
# 28 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypeinfo.h" 1
// @(#)root/base:$Id: Rtypeinfo.h 29770 2009-08-12 16:40:27Z rdm $
// Author: Philippe Canal   23/2/02

/*************************************************************************
 * Copyright (C) 1995-2002, Rene Brun, Fons Rademakers and al.           *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypeinfo.h"
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/typeinfo" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/typeinfo.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
/*********************************************************************
* typeinfo.h
*
*  Run time type identification
*
* Memo:
*   typeid(typename) , typeid(expression) is implemented as special 
*  function in the cint body src/G__func.c. 
*
*   As an extention, G__typeid(char *name) is defined in src/G__func.c
*  too for more dynamic use of the typeid.
*
*   type_info is extended to support non-polymorphic type objects.
*
*   In src/G__sizeof.c , G__typeid() is implemented. It relies on
*  specific binary layout of type_info object. If order of type_info
*  member declaration is modified, src/G__sizeof.c must be modified
*  too.
*
*********************************************************************/






# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/bool.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

/* 
   not needed anymore since v5.16.23,
   left for backward compatibility of possible user #includes
*/
# 35 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/typeinfo.h" 2

/*********************************************************************
* Functions embedded in cint core
* Most of those functions are defined in src/sizeof.c
* 
*********************************************************************/
// type_info typeid(expression);
// type_info typeid(char *typename);
// type_info G__typeid(char *expression);
// long G__get_classinfo(char *item,int tagnum);
// long G__get_variableinfo(char *item,long *handle,long *index,long tagnum);
// long G__get_functioninfo(char *item,long *handle,long &index,long tagnum);


/*********************************************************************
* type_info
*
*  Included in ANSI/ISO resolution proposal 1995 spring
* 
*********************************************************************/
class type_info {
 public:
  virtual ~type_info() { } // type_info is polymorphic
  bool operator==(const type_info&) const;
  bool operator!=(const type_info&) const;
  bool before(const type_info&) const;

  const char* name() const;

 private:
  type_info(const type_info&);
 protected: // original enhancement
  type_info& operator=(const type_info&);

  // implementation dependent representation
 protected:
  long type; // intrinsic types
  long tagnum; // class/struct/union
  long typenum; // typedefs
  long reftype; // pointing level and reference types
  long size; // size of the object

  long isconst; // constness


 public: // original enhancement
  type_info() { }
};


bool type_info::operator==(const type_info& a) const
{
  if(reftype == a.reftype && tagnum == a.tagnum && type == a.type)
    return(true);
  else
    return(false);
}

bool type_info::operator!=(const type_info& a) const
{
  if( *this == a ) return(false);
  else return(true);
}

bool type_info::before(const type_info& a) const
{
  if(-1!=tagnum)
    return( tagnum < a.tagnum );
  else if(-1!=a.tagnum)
    return( -1 < a.tagnum );
  else
    return( type < a.type );
}

const char* type_info::name() const
{
  static char namestring[100];
  //printf("%d %d %d %d\n",type,tagnum,typenum,reftype);


  char *cptr = G__type2string(type,tagnum,typenum,reftype,isconst);
  sprintf(namestring,"%d%s",strlen(cptr),cptr);






  return(namestring);
}

type_info::type_info(const type_info& a)
{
  type = a.type;
  tagnum = a.tagnum;
  typenum = a.typenum;
  reftype = a.reftype;
  size = a.size;

  isconst = a.isconst;

}

type_info& type_info::operator=(const type_info& a)
{
  type = a.type;
  tagnum = a.tagnum;
  typenum = a.typenum;
  reftype = a.reftype;
  size = a.size;

  isconst = a.isconst;

  return(*this);
}

/**************************************************************************
* original enhancment
**************************************************************************/
type_info::type_info()
{
  type = 0;
  tagnum = typenum = -1;
  reftype = 0;

  isconst = 0;

}


/**************************************************************************
* Further runtime type checking requirement from Fons Rademaker
**************************************************************************/

/*********************************************************************
* G__class_info
*
*********************************************************************/
class G__class_info : public type_info {
 public:
  G__class_info() { init(); }
  G__class_info(type_info& a) { init(a); }
  G__class_info(char *classname) { init(G__typeid(classname)); }

  void init() {
    typenum = -1;
    reftype = 0;
    tagnum = G__get_classinfo("next",-1);
    size = G__get_classinfo("size",tagnum);
    type = G__get_classinfo("type",tagnum);
  }

  void init(type_info& a) {
    type_info *p=this;
    *p = a;
  }

  G__class_info& operator=(G__class_info& a) {
    type = a.type;
    tagnum = a.tagnum;
    typenum = a.typenum;
    reftype = a.reftype;
    size = a.size;
  }

  G__class_info& operator=(type_info& a) {
    init(a);
  }

  G__class_info* next() {
    tagnum=G__get_classinfo("next",tagnum);
    if(-1!=tagnum) return(this);
    else {
      size = type = 0;
      return((G__class_info*)NULL);
    }
  }

  char *title() {
    return((char*)G__get_classinfo("title",tagnum));
  }

  // char *name() is inherited from type_info

  char *baseclass() {
    return((char*)G__get_classinfo("baseclass",tagnum));
  }


  int isabstract() {
    return((int)G__get_classinfo("isabstract",tagnum));
  }

  // can be implemented
  // int iscompiled();

  int Tagnum() {
    return(tagnum);
  }

};


/*********************************************************************
* G__variable_info
*
*********************************************************************/
class G__variable_info {
 public:
  G__variable_info() { init(); }
  G__variable_info(G__class_info& a) { init(a); }
  G__variable_info(char *classname) { init(G__class_info(classname)); }

  void init() {
    G__get_variableinfo("new",&handle,&index,tagnum=-1);
  }

  void init(G__class_info& a) {
    G__get_variableinfo("new",&handle,&index,tagnum=a.Tagnum());
  }

  G__variable_info* next() {
    if(G__get_variableinfo("next",&handle,&index,tagnum)) return(this);
    else return((G__variable_info*)NULL);
  }

  char *title() {
    return((char*)G__get_variableinfo("title",&handle,&index,tagnum));
  }

  char *name() {
    return((char*)G__get_variableinfo("name",&handle,&index,tagnum));
  }

  char *type() {
    return((char*)G__get_variableinfo("type",&handle,&index,tagnum));
  }

  int offset() {
    return((int)G__get_variableinfo("offset",&handle,&index,tagnum));
  }

  // can be implemented
  // char *access(); // return public,protected,private
  // int isstatic();
  // int iscompiled();

 private:
  long handle; // pointer to variable table
  long index;
  long tagnum; // class/struct identity
};

/*********************************************************************
* G__function_info
*
*********************************************************************/
class G__function_info {
 public:
  G__function_info() { init(); }
  G__function_info(G__class_info& a) { init(a); }
  G__function_info(char *classname) { init(G__class_info(classname)); }

  void init() {
    G__get_functioninfo("new",&handle,&index,tagnum=-1);
  } // initialize for global function

  void init(G__class_info& a) {
    G__get_functioninfo("new",&handle,&index,tagnum=a.Tagnum());
  } // initialize for member function

  G__function_info* next() {
    if(G__get_functioninfo("next",&handle,&index,tagnum)) return(this);
    else return((G__function_info*)NULL);
  }

  char *title() {
    return((char*)G__get_functioninfo("title",&handle,&index,tagnum));
  }

  char *name() {
    return((char*)G__get_functioninfo("name",&handle,&index,tagnum));
  }

  char *type() {
    return((char*)G__get_functioninfo("type",&handle,&index,tagnum));
  }

  char *arglist() {
    return((char*)G__get_functioninfo("arglist",&handle,&index,tagnum));
  }

  // can be implemented
  // char *access(); // return public,protected,private
  // int isstatic();
  // int iscompiled();
  // int isvirtual();
  // int ispurevirtual();

 private:
  long handle; // pointer to variable table
  long index;
  long tagnum; // class/struct identity
};

/*********************************************************************
* G__string_buf
*
*  This struct is used as temporary object for returning title strings.
* Size of buf[] limits maximum length of the title string you can
* describe. You can increase size of it here to increase it.
*
*********************************************************************/
struct G__string_buf {
  char buf[256];
};


/*********************************************************************
* Example code
*
*  Following functions are the examples of how to use the type info
* facilities.
*
*********************************************************************/


void G__list_class(void) {
  G__class_info a;
  do {
    printf("%s:%s =%d '%s'\n",a.name(),a.baseclass(),a.isabstract(),a.title());
  } while(a.next());
}

void G__list_class(char *classname) {
  G__list_memvar(classname);
  G__list_memfunc(classname);
}

void G__list_memvar(char *classname) {
  G__variable_info a=G__variable_info(G__typeid(classname));
  do {
    printf("%s %s; offset=%d '%s'\n",a.type(),a.name(),a.offset(),a.title());
  } while(a.next());
}

void G__list_memfunc(char *classname) {
  G__function_info a=G__function_info(G__typeid(classname));
  do {
    printf("%s %s(%s) '%s'\n",a.type(),a.name(),a.arglist(),a.title());
  } while(a.next());
}
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/typeinfo" 2
}
# 33 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypeinfo.h" 2
using std::type_info;
# 31 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 2


# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/stdio.h" 1



#pragma setstdio

typedef struct fpos_t {
  long l,u;
  fpos_t(long i=0){l=i;u=0;}
  void operator=(long i){l=i;u=0;}
} fpos_t;
#pragma link off class fpos_t;
#pragma link off typedef fpos_t;
# 30 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/stdio.h"
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/bool.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

/* 
   not needed anymore since v5.16.23,
   left for backward compatibility of possible user #includes
*/
# 31 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/stdio.h" 2

#pragma include_noerr <stdfunc.dll>
# 34 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/string.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
/****************************************************************
* string.h
*****************************************************************/
# 35 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/snprintf.h" 1
/* @(#)root/clib:$Id: snprintf.h 36336 2010-10-13 13:42:06Z rdm $ */
/* Author: Fons Rademakers  10/12/2000 */

/*
   Write formatted text to buffer 'string', using format string 'format'.
   Returns number of characters written, or -1 if truncated.
   Format string is understood as defined in ANSI C.
*/
# 50 "/nfs/RAID/opt/root/v5.34.01_sl61/include/snprintf.h"
int snprintf(char *string, size_t length, const char *format, ...);
# 36 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/strlcpy.h" 1
/* @(#)root/clib:$Id: strlcpy.h 36336 2010-10-13 13:42:06Z rdm $ */
/* Author: Fons Rademakers  20/9/2010 */

/*
   Inlcude file for strlcpy and strlcat. They are in string.h on systems
   that have these function (BSD based systems).
*/
# 41 "/nfs/RAID/opt/root/v5.34.01_sl61/include/strlcpy.h"
size_t strlcpy(char *dst, const char *src, size_t siz);
size_t strlcat(char *dst, const char *src, size_t siz);
# 37 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 2



//---- forward declared class types --------------------------------------------

class TClass;
class TBuffer;
class TDirectory;
class TMemberInspector;
class TObject;
class TNamed;
class TRootIOCtor;
class TCollection;
class TFileMergeInfo;
class TString;

//---- types -------------------------------------------------------------------

typedef char Char_t; //Signed Character 1 byte (char)
typedef unsigned char UChar_t; //Unsigned Character 1 byte (unsigned char)
typedef short Short_t; //Signed Short integer 2 bytes (short)
typedef unsigned short UShort_t; //Unsigned Short integer 2 bytes (unsigned short)




typedef int Int_t; //Signed integer 4 bytes (int)
typedef unsigned int UInt_t; //Unsigned integer 4 bytes (unsigned int)


typedef int Seek_t; //File pointer (int)
typedef long Long_t; //Signed long integer 8 bytes (long)
typedef unsigned long ULong_t; //Unsigned long integer 8 bytes (unsigned long)





typedef float Float_t; //Float 4 bytes (float)
typedef float Float16_t; //Float 4 bytes written with a truncated mantissa
typedef double Double_t; //Double 8 bytes
typedef double Double32_t; //Double 8 bytes in memory, written as a 4 bytes float
typedef char Text_t; //General string (char)
typedef bool Bool_t; //Boolean (0=false, 1=true) (bool)
typedef unsigned char Byte_t; //Byte (8 bits) (unsigned char)
typedef short Version_t; //Class version identifier (short)
typedef const char Option_t; //Option string (const char)
typedef int Ssiz_t; //String size (int)
typedef float Real_t; //TVector and TMatrix element type (float)




typedef long long Long64_t; //Portable signed long integer 8 bytes
typedef unsigned long long ULong64_t;//Portable unsigned long integer 8 bytes

typedef double Axis_t; //Axis values type (double)
typedef double Stat_t; //Statistics type (double)

typedef short Font_t; //Font number (short)
typedef short Style_t; //Style number (short)
typedef short Marker_t; //Marker number (short)
typedef short Width_t; //Line width (short)
typedef short Color_t; //Color number (short)
typedef short SCoord_t; //Screen coordinates (short)
typedef double Coord_t; //Pad world coordinates (double)
typedef float Angle_t; //Graphics angle (float)
typedef float Size_t; //Attribute size (float)

enum EColor { kWhite =0, kBlack =1, kGray=920,
              kRed =632, kGreen =416, kBlue=600, kYellow=400, kMagenta=616, kCyan=432,
              kOrange=800, kSpring=820, kTeal=840, kAzure =860, kViolet =880, kPink=900 };

// There is several streamer concepts.
class TClassStreamer; // Streamer functor for a class
class TMemberStreamer; // Streamer functor for a data member
typedef void (*ClassStreamerFunc_t)(TBuffer&, void*); // Streamer function for a class
typedef void (*MemberStreamerFunc_t)(TBuffer&, void*, Int_t); // Streamer function for a data member

// This class is used to implement proxy around collection classes.
class TVirtualCollectionProxy;

typedef void (*VoidFuncPtr_t)(); //pointer to void function


//---- constants ---------------------------------------------------------------
# 134 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h"
const Bool_t kTRUE = true;
const Bool_t kFALSE = false;

const Int_t kMaxUChar = 256;
const Int_t kMaxChar = kMaxUChar >> 1;
const Int_t kMinChar = -kMaxChar - 1;

const Int_t kMaxUShort = 65534;
const Int_t kMaxShort = kMaxUShort >> 1;
const Int_t kMinShort = -kMaxShort - 1;

const UInt_t kMaxUInt = UInt_t(~0);
const Int_t kMaxInt = Int_t(kMaxUInt >> 1);
const Int_t kMinInt = -kMaxInt - 1;

const ULong_t kMaxULong = ULong_t(~0);
const Long_t kMaxLong = Long_t(kMaxULong >> 1);
const Long_t kMinLong = -kMaxLong - 1;

const ULong64_t kMaxULong64 = ULong64_t(~0LL);
const Long64_t kMaxLong64 = Long64_t(kMaxULong64 >> 1);
const Long64_t kMinLong64 = -kMaxLong64 - 1;

const size_t kBitsPerByte = 8;
const Ssiz_t kNPOS = ~(Ssiz_t)0;


//--- bit manipulation ---------------------------------------------------------







//---- debug global ------------------------------------------------------------

extern Int_t gDebug;


//---- ClassDef macros ---------------------------------------------------------

typedef void (*ShowMembersFunc_t)(void *obj, TMemberInspector &R__insp);
class TVirtualIsAProxy;
typedef TClass *(*IsAGlobalFunc_t)(const TClass*, const void *obj);

// TBuffer.h declares and implements the following 2 operators
template <class Tmpl> TBuffer &operator>>(TBuffer &buf, Tmpl *&obj);
template <class Tmpl> TBuffer &operator<<(TBuffer &buf, const Tmpl *obj);

// This might get used if we implement setting a class version.
// template <class RootClass> Short_t GetClassVersion(RootClass *);

namespace ROOT {

   class TGenericClassInfo;
   typedef void *(*NewFunc_t)(void *);
   typedef void *(*NewArrFunc_t)(Long_t size, void *arena);
   typedef void (*DelFunc_t)(void *);
   typedef void (*DelArrFunc_t)(void *);
   typedef void (*DesFunc_t)(void *);
   typedef void (*DirAutoAdd_t)(void *, TDirectory *);
   typedef Long64_t (*MergeFunc_t)(void *, TCollection *, TFileMergeInfo *);
   typedef void (*ResetAfterMergeFunc_t)(void *, TFileMergeInfo *);

   template <class RootClass> Short_t SetClassVersion(RootClass *);

   extern TClass *CreateClass(const char *cname, Version_t id,
                              const type_info &info, TVirtualIsAProxy *isa,
                              ShowMembersFunc_t show,
                              const char *dfil, const char *ifil,
                              Int_t dl, Int_t il);
   extern void AddClass(const char *cname, Version_t id, const type_info &info,
                        VoidFuncPtr_t dict, Int_t pragmabits);
   extern void RemoveClass(const char *cname);
   extern void ResetClassVersion(TClass*, const char*, Short_t);

   extern TNamed *RegisterClassTemplate(const char *name,
                                        const char *file, Int_t line);
# 225 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h"
   class TInitBehavior {
      // This class defines the interface for the class registration and
      // the TClass creation. To modify the default behavior, one would
      // inherit from this class and overload ROOT::DefineBehavior().
      // See TQObject.h and table/inc/Ttypes.h for examples.
   public:
      virtual ~TInitBehavior() { }
      virtual void Register(const char *cname, Version_t id, const type_info &info,
                            VoidFuncPtr_t dict, Int_t pragmabits) const = 0;
      virtual void Unregister(const char *classname) const = 0;
      virtual TClass *CreateClass(const char *cname, Version_t id,
                                  const type_info &info, TVirtualIsAProxy *isa,
                                  ShowMembersFunc_t show,
                                  const char *dfil, const char *ifil,
                                  Int_t dl, Int_t il) const = 0;
   };

   class TDefaultInitBehavior : public TInitBehavior {
   public:
      virtual void Register(const char *cname, Version_t id, const type_info &info,
                            VoidFuncPtr_t dict, Int_t pragmabits) const {
         ROOT::AddClass(cname, id, info, dict, pragmabits);
      }
      virtual void Unregister(const char *classname) const {
         ROOT::RemoveClass(classname);
      }
      virtual TClass *CreateClass(const char *cname, Version_t id,
                                  const type_info &info, TVirtualIsAProxy *isa,
                                  ShowMembersFunc_t show,
                                  const char *dfil, const char *ifil,
                                  Int_t dl, Int_t il) const {
         return ROOT::CreateClass(cname, id, info, isa, show, dfil, ifil, dl, il);
      }
   };

   const TInitBehavior *DefineBehavior(void * /*parent_type*/,
                                       void * /*actual_type*/);

} // End of namespace ROOT

// The macros below use TGenericClassInfo, so let's ensure it is included

# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGenericClassInfo.h" 1
// @(#)root/base:$Id: TGenericClassInfo.h 39611 2011-06-08 19:35:17Z pcanal $
// Author: Philippe Canal   23/2/02

/*************************************************************************
 * Copyright (C) 1995-2002, Rene Brun, Fons Rademakers and al.           *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/vector" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_vector" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <vector.dll>
#pragma include_noerr <vectorbool.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/vector

#pragma ifndef PREC_STL_VECTOR
#pragma define PREC_STL_VECTOR
#pragma link off global PREC_STL_VECTOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from ANSI/ISO C++ 1997/Nov draft 
// Got some ideas from Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <iterator.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/iterator

#pragma ifndef PREC_STL_ITERATOR
#pragma define PREC_STL_ITERATOR
#pragma link off global PREC_STL_ITERATOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from STL HP implementation 1994
// Imported from STL SGI implementation 1997 
// Imported from ANSI/ISO C++ draft Nov 1997
// Modified by Masaharu Goto
// May need improvement for the latest standard


////////////////////////////////////////////////////////////////////////
// iterator_tag
////////////////////////////////////////////////////////////////////////
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag {};
struct bidirectional_iterator_tag {};
struct random_access_iterator_tag {};

////////////////////////////////////////////////////////////////////////
// iterator template
////////////////////////////////////////////////////////////////////////
template <class T, class Distance> struct input_iterator {};
struct output_iterator {};
template <class T, class Distance> struct forward_iterator {};
template <class T, class Distance> struct bidirectional_iterator {};
template <class T, class Distance> struct random_access_iterator {};

#pragma link off class output_iterator;







////////////////////////////////////////////////////////////////////////
// iterator_category overloaded function
////////////////////////////////////////////////////////////////////////
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const input_iterator<T, Distance>&) {
    return input_iterator_tag();
}

inline output_iterator_tag iterator_category(const output_iterator&) {
    return output_iterator_tag();
}

#pragma link off function iterator_category(const output_iterator&);


template <class T, class Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<T, Distance>&) {
    return forward_iterator_tag();
}

template <class T, class Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<T, Distance>&) {
    return bidirectional_iterator_tag();
}

template <class T, class Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<T, Distance>&) {
    return random_access_iterator_tag();
}

template <class T>
inline random_access_iterator_tag
iterator_category(const T*) {
    return random_access_iterator_tag();
}


// iterator_traits, iterator and reverse_iterator template may not be
// needed for precompiled library interface 

////////////////////////////////////////////////////////////////////////
// iterator_traits
////////////////////////////////////////////////////////////////////////

template <class Iterator>
struct iterator_traits {
  typedef typename Iterator::iterator_category iterator_category;
  typedef typename Iterator::value_type value_type;
  typedef typename Iterator::difference_type difference_type;
  typedef typename Iterator::pointer pointer;
  typedef typename Iterator::reference reference;
};

// template partial specialization, implement in cint5.15.14 1587
template <class T>
struct iterator_traits<T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef T& reference;
};

// incomplete implementation in cint5.15.14 1587, need some fix
// iterator_traits<const int*> is changed as iterator_traits<const int* const>
// or something, but cint5.15.14 can not handle this well
template <class T>
struct iterator_traits<const T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef const T* pointer;
  typedef const T& reference;
};

////////////////////////////////////////////////////////////////////////
// iterator
////////////////////////////////////////////////////////////////////////
template<class Category, class T, class Distance = ptrdiff_t,
         class Pointer = T*, class Reference = T&>
struct iterator {
  typedef T value_type;
  typedef Distance difference_type;
  typedef Pointer pointer;
  typedef Reference reference;
  typedef Category iterator_category;
};


////////////////////////////////////////////////////////////////////////
// reverse_iterator
////////////////////////////////////////////////////////////////////////






template <class Iterator>
class reverse_iterator
# 166 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
{




 public:
# 181 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
   typedef Iterator::pointer pointer;
   typedef Iterator::reference reference;
   typedef ptrdiff_t difference_type;


   reverse_iterator();
   //reverse_iterator(Iterator x);



   Iterator base() const; // explicit
   reference operator*() const;
   pointer operator->() const;
   reverse_iterator& operator++();
   reverse_iterator operator++(int);
   reverse_iterator& operator--();
   reverse_iterator operator--(int);
   reverse_iterator operator+ (difference_type n) const;
   reverse_iterator& operator+=(difference_type n);
   reverse_iterator operator- (difference_type n) const;
   reverse_iterator& operator-=(difference_type n);
   reference operator[](difference_type n) const;
};
# 932 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
// for g++ 3.1,3.2
namespace __gnu_cxx
{
  // This iterator adapter is 'normal' in the sense that it does not
  // change the semantics of any of the operators of its iterator
  // parameter.  Its primary purpose is to convert an iterator that is
  // not a class, e.g. a pointer, into an iterator that is a class.
  // The _Container parameter exists solely so that different containers
  // using this template can instantiate different types, even if the
  // _Iterator parameter is the same.
  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
      : public iterator<typename iterator_traits<_Iterator>::iterator_category,
                        typename iterator_traits<_Iterator>::value_type,
                        typename iterator_traits<_Iterator>::difference_type,
                        typename iterator_traits<_Iterator>::pointer,
                        typename iterator_traits<_Iterator>::reference>
    {
    protected:
      _Iterator _M_current;

    public:
      typedef typename iterator_traits<_Iterator>::difference_type
                    difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

      __normal_iterator() : _M_current(_Iterator()) { }

      explicit
      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

      // Allow iterator to const_iterator conversion
      template<typename _Iter>
      inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
 : _M_current(__i.base()) { }

      // Forward iterator requirements
      reference
      operator*() const { return *_M_current; }

      pointer
      operator->() const { return _M_current; }

      __normal_iterator&
      operator++() { ++_M_current; return *this; }

      __normal_iterator
      operator++(int) { return __normal_iterator(_M_current++); }

      // Bidirectional iterator requirements
      __normal_iterator&
      operator--() { --_M_current; return *this; }

      __normal_iterator
      operator--(int) { return __normal_iterator(_M_current--); }

      // Random access iterator requirements
      reference
      operator[](const difference_type& __n) const
      { return _M_current[__n]; }

      __normal_iterator&
      operator+=(const difference_type& __n)
      { _M_current += __n; return *this; }

      __normal_iterator
      operator+(const difference_type& __n) const
      { return __normal_iterator(_M_current + __n); }

      __normal_iterator&
      operator-=(const difference_type& __n)
      { _M_current -= __n; return *this; }

      __normal_iterator
      operator-(const difference_type& __n) const
      { return __normal_iterator(_M_current - __n); }

      const _Iterator&
      base() const { return _M_current; }
    };

  // Note: In what follows, the left- and right-hand-side iterators are
  // allowed to vary in types (conceptually in cv-qualification) so that
  // comparaison between cv-qualified and non-cv-qualified iterators be
  // valid.  However, the greedy and unfriendly operators in std::rel_ops
  // will make overload resolution ambiguous (when in scope) if we don't
  // provide overloads whose operands are of the same type.  Can someone
  // remind me what generic programming is about? -- Gaby

  // Forward iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  // Random access iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  // _GLIBCPP_RESOLVE_LIB_DEFECTS
  // According to the resolution of DR179 not only the various comparison
  // operators but also operator- must accept mixed iterator/const_iterator
  // parameters.
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
     const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
} // namespace __gnu_cxx







#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 2
# 27 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_memory" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <memory.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/memory

#pragma ifndef PREC_STL_MEMORY
#pragma define PREC_STL_MEMORY
#pragma link off global PREC_STL_MEMORY;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

// Implemented by Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/stddef.h" 1





typedef long ptrdiff_t;

typedef unsigned int wchar_t;
# 21 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory" 2






//////////////////////////////////////////////////////////////////////


template <class _Tp>
class allocator {
  //typedef alloc _Alloc;          // The underlying allocator.
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef typename _Tp* pointer;
  typedef const typename _Tp * const_pointer;




  typedef _Tp& reference;
  typedef const _Tp& const_reference;
  typedef _Tp value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };

  allocator() ;
  allocator(const allocator&) ;
  //template <class _Tp1> allocator(const allocator<_Tp1>&) ;
  ~allocator() ;

  pointer address(reference __x) const ;
  const_pointer address(const_reference __x) const ;

  // __n is permitted to be 0.  The C++ standard says nothing about what
  // the return value is when __n == 0.
  _Tp* allocate(size_type __n, const void* = 0) ;

  // __p is not permitted to be a null pointer.
  void deallocate(pointer __p, size_type __n);

  size_type max_size() const ;

  void construct(pointer __p, const _Tp& __val) ;
  void destroy(pointer __p) ;
};

template<>
class allocator<void> {
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef void* pointer;
  typedef const void* const_pointer;
  typedef void value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };
};
//////////////////////////////////////////////////////////////////////
# 205 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
//////////////////////////////////////////////////////////////////////

/**********************************************************************
* auto_ptr
**********************************************************************/
template <class X> class auto_ptr {
private:
  X* ptr;
  //template<class Y> struct auto_ptr_ref { };
public:
  typedef X element_type;
  explicit auto_ptr(X* p = 0) : ptr(p) {}
  auto_ptr(auto_ptr& a) {ptr=a.ptr;}

  // this implementation may not be correct
  template <class T> auto_ptr(auto_ptr<T>& a) {ptr=a.release();}
# 229 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
  auto_ptr& operator=(auto_ptr& a) {
    if (a.ptr != ptr) {
      delete ptr;
      ptr = a.ptr;
    }
    return(*this);
  }

  // this implementation may not be correct
  template <class T> auto_ptr& operator=(auto_ptr<T>& a) {
    if (a.ptr != ptr) {
       delete ptr;
       ptr = a.release();
    }
    return(*this);
  }

  ~auto_ptr() { delete ptr; }

  X& operator*() const { return *ptr; }
  X* operator->() const { return ptr; }
  X* get() const { return ptr; }
  X* release() { X *old = ptr; ptr = 0; return 0; }
# 262 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
  // auto_ptr conversions
  //auto_ptr(auto_ptr_ref<X>& x) { }
  //template<class Y> operator auto_ptr_ref<Y>() { return auto_ptr_ref<Y>(); }
  //template<class Y> operator auto_ptr<Y>() { return auto_ptr<T>(); }
};

#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_memory" 2
# 28 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_utility" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <utility.dll>


#pragma include_noerr <pair.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/utility" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/utility

#pragma ifndef PREC_STL_UTILITY
#pragma define PREC_STL_UTILITY
#pragma link off global PREC_STL_UTILITY;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

template <class T1, class T2>
struct pair {
  T1 first;
  T2 second;
  pair() : first(T1()), second(T2()) {}
  pair(const T1& a, const T2& b) : first(a), second(b) {}
 private:
  pair& operator=(const pair& x){first=x.first;second=x.second;return *this;}
};

#pragma endif
# 17 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_utility" 2
# 29 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector" 2
# 37 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
template<class T,class Allocator=std::allocator<T> >
# 49 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
class vector {
 public:
  typedef T value_type;


  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
# 218 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
  class iterator {
   public:
     typedef vector::pointer pointer;
     typedef vector::const_pointer const_pointer;
     typedef vector::reference reference;
     typedef vector::const_reference const_reference;
     typedef vector::size_type size_type;
     typedef vector::difference_type difference_type;

      iterator();
      explicit iterator(const pointer& __i) ;
      // Allow iterator to const_iterator conversion
      template<typename _Iter> inline iterator(const iterator& __i);

      // Forward iterator requirements
      reference operator*() const ;
      pointer operator->() const ;
      iterator& operator++();
      iterator operator++(int) ;

      // Bidirectional iterator requirements
      iterator& operator--() ;
      iterator operator--(int) ;

      // Random access iterator requirements
      reference operator[](const difference_type& __n) const;
      iterator& operator+=(const difference_type& __n);
      iterator operator+(const difference_type& __n) const;
      iterator& operator-=(const difference_type& __n);
      iterator operator-(const difference_type& __n) const;
      const pointer& base() const ;

      iterator operator=(const iterator& x) ;

  };

  friend bool operator==(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator!=(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator<(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator>(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator<=(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator>=(const vector::iterator& x,const vector::iterator& y)const;
  friend vector::iterator::difference_type operator-(const vector::iterator& x,const vector::iterator& y)const;
  friend vector::iterator operator+(const vector::iterator::difference_type x,const vector::iterator& y)const;

  typedef const iterator const_iterator;
# 355 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator> reverse_iterator;
# 398 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
  friend bool operator==(const vector::reverse_iterator& x
                        ,const vector::reverse_iterator& y) const;
  friend bool operator!=(const vector::reverse_iterator& x
                        ,const vector::reverse_iterator& y) const;






  friend bool operator==(vector::const_iterator& x
                        ,vector::const_iterator& y) const;
  friend bool operator!=(vector::const_iterator& x
                        ,vector::const_iterator& y) const;
# 422 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
  reference at(size_type n);
  const_reference at(size_type n) const;

  iterator begin(void) ;
  iterator end(void) ;
  reverse_iterator rbegin(void) ;
  reverse_iterator rend(void) ;






  size_type size(void) const ;
  size_type max_size(void) const ;
  void resize(size_type sz) ;
  void resize(size_type sz, T c) ;
  size_type capacity(void) const ;
  bool empty(void) const ;
  reference operator[](size_type n) ;
  const_reference operator[](size_type n) const;
  vector(void) ;
  vector(size_type n,const T& value=T()) ;
  vector(const vector& x) ;
  vector(const_iterator first,const_iterator last) ;
  ~vector(void) ;
  vector& operator=(const vector& x);
  void reserve(size_type n) ;
  T& front(void) ;
  T& back(void) ;
  void push_back(const T& x) ;
  void swap(vector& x);
  iterator insert(iterator position,const T& x);
  void insert(iterator position,const_iterator first,const_iterator last);
  void insert(iterator position,size_type n,const T& x);
  void pop_back(void) ;
  void erase(iterator position) ;
  void erase(iterator first,iterator last) ;
  void clear() ;


  friend bool operator==(const vector& x, const vector& y);
  friend bool operator< (const vector& x, const vector& y);
  friend bool operator!=(const vector& x, const vector& y);
  friend bool operator> (const vector& x, const vector& y);
  friend bool operator>=(const vector& x, const vector& y);
  friend bool operator<=(const vector& x, const vector& y);



  // specialized algorithms:






#pragma ifndef G__NOALGORITHM

  // Generic algorithm


  // input iter
  friend vector::iterator
    find(vector::iterator first,vector::iterator last,const T& value);
  // forward iter
  friend vector::iterator
    find_end(vector::iterator first1,vector::iterator last1,
      vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    find_first_of(vector::iterator first1,vector::iterator last1,
           vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    adjacent_find(vector::iterator first,vector::iterator last);
  // input iter

  friend vector::difference_type
    count(vector::iterator first,vector::iterator last,const T& value);






  friend bool
    equal(vector::iterator first1,vector::iterator last1,
          vector::iterator first2);
  // forward iter
  friend vector::iterator
    search(vector::iterator first1,vector::iterator last1,
           vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    search_n(vector::iterator first,vector::iterator last
             ,vector::size_type count,const T& value);
  // input and output iter -> forward iter
  friend vector::iterator
    copy(vector::iterator first,vector::iterator last,
         vector::iterator result);
  // bidirectional iter
  friend vector::iterator
    copy_backward(vector::iterator first,vector::iterator last,
                  vector::iterator result);
  // just value_type
  friend void swap(T& a,T& b);
  // forward iter
  friend vector::iterator
    swap_ranges(vector::iterator first1,vector::iterator last1,
                vector::iterator first2);
  friend void iter_swap(vector::iterator a,vector::iterator b);
  friend void replace(vector::iterator first,vector::iterator last,
                      const T& old_value,const T& new_value);
  // input, output iter -> forward iter
  friend vector::iterator
    replace_copy(vector::iterator first,vector::iterator last,
                 vector::iterator result,
                 const T& old_value,const T& new_value);
  // forward iter
  friend void
    fill(vector::iterator first,vector::iterator last,const T& value);

  friend void
    fill_n(vector::iterator first,vector::size_type n,const T& value);

  friend vector::iterator
    remove(vector::iterator first,vector::iterator last,const T& value);
  // input,output iter -> forward iter
  friend vector::iterator
    remove_copy(vector::iterator first,vector::iterator last,
                vector::iterator result,const T& value);
  friend vector::iterator
    unique(vector::iterator first,vector::iterator last);
  friend vector::iterator
    unique_copy(vector::iterator first,vector::iterator last,
                vector::iterator result);
  friend void reverse(vector::iterator first,vector::iterator last);
  friend vector::iterator
     reverse_copy(vector::iterator first,vector::iterator last,
                  vector::iterator result);
  // forward iter

  friend void rotate(vector::iterator first,vector::iterator mid,
                     vector::iterator last);

  // forward iter
  friend vector::iterator
    rotate_copy(vector::iterator first,vector::iterator mid,
                vector::iterator last,vector::iterator result);
  // randomaccess iter
  friend void random_shuffle(vector::iterator first,vector::iterator last);
  // randomaccess iter
  friend void sort(vector::iterator first,vector::iterator last);
  friend void stable_sort(vector::iterator first,vector::iterator last);
  friend void partial_sort(vector::iterator first,vector::iterator mid,
                           vector::iterator last);
  friend vector::iterator
    partial_sort_copy(vector::iterator first,vector::iterator last,
                      vector::iterator result_first,
                      vector::iterator result_last);
  friend void nth_element(vector::iterator first,vector::iterator nth,
                          vector::iterator last);
  // forward iter
  friend vector::iterator
    lower_bound(vector::iterator first,vector::iterator last,const T& value);
  friend vector::iterator
    upper_bound(vector::iterator first,vector::iterator last,const T& value);




  friend bool binary_search(vector::iterator first,vector::iterator last,
                            const T& value);
  friend vector::iterator merge(vector::iterator first1,vector::iterator last1,
                                vector::iterator first2,vector::iterator last2,
                                vector::iterator result);
  friend void inplace_merge(vector::iterator first,vector::iterator middle,
                            vector::iterator last);
  friend bool includes(vector::iterator first1,vector::iterator last1,
                       vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    set_union(vector::iterator first1,vector::iterator last1,
              vector::iterator first2,vector::iterator last2,
              vector::iterator result);
  friend vector::iterator
    set_intersection(vector::iterator first1,vector::iterator last1,
                     vector::iterator first2,vector::iterator last2,
                     vector::iterator result);
  friend vector::iterator
    set_difference(vector::iterator first1,vector::iterator last1,
                   vector::iterator first2,vector::iterator last2,
                   vector::iterator result);
  friend vector::iterator
    set_symmetric_difference(vector::iterator first1,vector::iterator last1,
                             vector::iterator first2,vector::iterator last2,
                             vector::iterator result);
  // random access
  friend void push_heap(vector::iterator first,vector::iterator last);
  friend void pop_heap(vector::iterator first,vector::iterator last);
  friend void make_heap(vector::iterator first,vector::iterator last);
  friend void sort_heap(vector::iterator first,vector::iterator last);
  // min,max, just value_type
  friend const T& min(const T& a,const T& b);
  friend const T& max(const T& a,const T& b);
  // forward iter
  friend vector::iterator
    min_element(vector::iterator first,vector::iterator last);
  friend vector::iterator
    max_element(vector::iterator first,vector::iterator last);
  // input iter
  friend bool
    lexicographical_compare(vector::iterator first1,vector::iterator last1,
                            vector::iterator first2,vector::iterator last2);
  // bidirectional iter
  friend bool next_permutation(vector::iterator first,vector::iterator last);
  friend bool prev_permutation(vector::iterator first,vector::iterator last);
# 662 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
#pragma endif

  // iterator_category resolution
  //friend random_access_iterator_tag iterator_category(vector::iterator x);

};
# 837 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
#pragma endif
# 15 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_vector" 2
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/vector" 2
}
# 16 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGenericClassInfo.h" 2
//#ifndef ROOT_TSchemaHelper
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSchemaHelper.h" 1
// @(#)root/core:$Id: TSchemaHelper.h 43515 2012-03-27 21:15:53Z pcanal $
// author: Lukasz Janyst <ljanyst@cern.ch>

/*************************************************************************
 * Copyright (C) 1995-2010, Rene Brun, Fons Rademakers and al.           *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

// This include must be outside of the code guard because
// Rtypes.h includes TGenericClassInfo.h which includes
// TSchemaHelper.h (this header file) and really need the
// definition of ROOT::TSchemaHelper.   So in this case,
// we need the indirect #include to really do the declaration
// and the direct #include to be a noop.







# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/string" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_string" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// string





#pragma include_noerr <string.dll>




# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/string" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/string

#pragma ifndef PREC_STL_STRING
#pragma define PREC_STL_STRING
#pragma link off global PREC_STL_STRING;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// string class wrapper , by Masaharu Goto
// Template is on purposely avoided.


# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * I/O stream header file iostream.h
 ************************************************************************
 * Description:
 *  CINT iostream header file
 ************************************************************************
 * Copyright(c) 1995~1999  Masaharu Goto 
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/



/*********************************************************************
* Try initializaing precompiled iostream library
*********************************************************************/
#pragma setstream
#pragma ifdef G__IOSTREAM_H

#pragma ifdef G__TMPLTIOS
typedef ios_base ios;
#pragma else
typedef ios ios_base;
#pragma endif

#pragma ifndef G__KCC
#pragma include <iosenum.h>

#pragma ifndef G__SSTREAM_H
typedef ostrstream ostringstream;
typedef istrstream istringstream;
//typedef strstream stringstream;  // problem, 
#pragma else
typedef ostringstream ostrstream;
typedef istringstream istrstream;
typedef stringstream strstream;
#pragma endif

#pragma endif

#pragma endif

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/bool.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

/* 
   not needed anymore since v5.16.23,
   left for backward compatibility of possible user #includes
*/
# 48 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream.h" 2

/*********************************************************************
* Use fake iostream only if precompiled version does not exist.
*********************************************************************/
#pragma if !defined(G__IOSTREAM_H)


#pragma security level0



/*********************************************************************
* ios
*
*********************************************************************/
typedef long streamoff;
typedef long streampos;
//class io_state;
class streambuf;
class fstreambase;
typedef long SZ_T;
typedef SZ_T streamsize;

class ios {
 public:
  typedef int iostate;
  enum io_state {
    goodbit = 0x00,
    badbit = 0x01,
    eofbit = 0x02,
    failbit = 0x04
  };
  typedef int openmode;
  enum open_mode {
    app = 0x01,
    binary = 0x02,
    in = 0x04,
    out = 0x08,
    trunc = 0x10,
    ate = 0x20
  };
  typedef int seekdir;
  enum seek_dir {
    beg = 0x0,
    cur = 0x1,
    end = 0x2
  };
  typedef int fmtflags;
  enum fmt_flags {
    boolalpha = 0x0001,
    dec = 0x0002,
    fixed = 0x0004,
    hex = 0x0008,
    internal = 0x0010,
    left = 0x0020,
    oct = 0x0040,
    right = 0x0080,
    scientific = 0x0100,
    showbase = 0x0200,
    showpoint = 0x0400,
    showpos = 0x0800,
    skipws = 0x1000,
    unitbuf = 0x2000,
    uppercase = 0x4000,
    adjustfield = left | right | internal,
    basefield = dec | oct | hex,
    floatfield = scientific | fixed
  };
  enum event {
    erase_event = 0x0001,
    imbue_event = 0x0002,
    copyfmt_event = 0x0004
  };

  ios() { x_width=0; }
  streamsize width(streamsize wide) { x_width=wide; }
 protected:
  int x_width;
};


/*********************************************************************
* ostream
*
*********************************************************************/

class ostream : /* virtual */ public ios {
 FILE *fout;
      public:
 ostream(FILE *setfout) { fout=setfout; }
 ostream(char *fname) ;
 ~ostream() ;
 void close() { if(fout) fclose(fout); fout=0;}
 void flush() { if(fout) fflush(fout); }
 FILE *fp() { return(fout); }
 int rdstate() ;

 ostream& operator <<(char c);
 ostream& operator <<(char *s);
 ostream& operator <<(long i);
 ostream& operator <<(unsigned long i);
 ostream& operator <<(double d);
 ostream& operator <<(void *p);
 ostream& form(char *format ...);
};

ostream::~ostream()
{
  if(fout!=stderr && fout!=stdout && fout!=0) {
    fclose(fout);
  }
}

ostream::ostream(char *fname)
{
  fout = fopen(fname,"w");
  if(fout==0) {
    fprintf(stderr,"%s can not open\n",fname);
  }
}

ostream& ostream::operator <<(char c)
{
  if(x_width) {
    int init=0;
    if(isprint(c)) init=1;
    for(int i=init;i<x_width;i++) fputc(' ',fout);
    x_width=0;
  }
  fprintf(fout,"%c",c);
  return(*this);
}

ostream& ostream::operator <<(char *s)
{
  if(x_width &&(!s || x_width>strlen(s))) {
    if(s) for(int i=strlen(s);i<x_width;i++) fputc(' ',fout);
    else for(int i=0;i<x_width;i++) fputc(' ',fout);
    x_width=0;
  }
  fprintf(fout,"%s",s);
  return(*this);
}

ostream& ostream::operator <<(long x)
{
  if(x_width) {
    char buf[50];
    sprintf(buf,"%d",x);
    if(x_width>strlen(buf))
      for(int i=strlen(buf);i<x_width;i++) fputc(' ',fout);
    x_width=0;
  }
  fprintf(fout,"%d",x);
  return(*this);
}

ostream& ostream::operator <<(unsigned long x)
{
  if(x_width) {
    char buf[50];
    sprintf(buf,"%u",x);
    if(x_width>strlen(buf))
      for(int i=strlen(buf);i<x_width;i++) fputc(' ',fout);
    x_width=0;
  }
  fprintf(fout,"%u",x);
  return(*this);
}

ostream& ostream::operator <<(double d)
{
  if(x_width) {
    char buf[50];
    sprintf(buf,"%g",d);
    if(x_width>strlen(buf))
      for(int i=strlen(buf);i<x_width;i++) fputc(' ',fout);
    x_width=0;
  }
  fprintf(fout,"%g",d);
  return(*this);
}

ostream& ostream::operator <<(void *p)
{
  if(x_width) {
    char buf[50];
    sprintf(buf,"0x%x",p);
    if(x_width>strlen(buf))
      for(int i=strlen(buf);i<x_width;i++) fputc(' ',fout);
    x_width=0;
  }
  printf("0x%x",p);
  return(*this);
}

int ostream::rdstate()
{
  if(fout) return(0);
  else return(1);
}

/* instanciation of cout,cerr */
ostream cout=ostream(stdout);
ostream cerr=ostream(stderr);


/*********************************************************************
* istream
*
*********************************************************************/

class istream : /* virtual */ public ios {
  FILE *fin;
  ostream *tie;
public:
  istream(FILE *setfin) { fin = setfin; tie=(ostream*)0; }
  istream(char *fname);
  ~istream();
  void close() { if(fin) fclose(fin); fin=0;}
  ostream& tie(ostream& cx);
  FILE *fp() { return(fin); }
  int rdstate();

  istream& operator >>(char& c);
  istream& operator >>(char *s);
  istream& operator >>(short& s);
  istream& operator >>(int& i);
  istream& operator >>(long& i);
  istream& operator >>(unsigned char& c);
  istream& operator >>(unsigned short& s);
  istream& operator >>(unsigned int& i);
  istream& operator >>(unsigned long& i);
  istream& operator >>(double& d);
  istream& operator >>(float& d);
};

istream::~istream()
{
  if(fin!=stdin && fin!=0) {
    fclose(fin);
  }
}

istream::istream(char *fname)
{
  fin = fopen(fname,"r");
  if(fin==0) {
    fprintf(stderr,"%s can not open\n",fname);
  }
  tie=(ostream*)0;
}


ostream& istream::tie(ostream& cx)

{
  ostream *tmp;
  tmp=tie;
  tie = &cx;
  return(*tmp);
}

istream& istream::operator >>(char& c)
{
  if(tie) tie->flush();
  c=fgetc(fin);
  return(*this);
}

istream& istream::operator >>(char *s)
{
  if(tie) tie->flush();
  fscanf(fin,"%s",s);
  return(*this);
}

istream& istream::operator >>(short& s)
{
  if(tie) tie->flush();
  fscanf(fin,"%hd",&s);
  return(*this);
}

istream& istream::operator >>(int& i)
{
  if(tie) tie->flush();
  fscanf(fin,"%d",&i);
  return(*this);
}

istream& istream::operator >>(long& i)
{
  if(tie) tie->flush();
  fscanf(fin,"%ld",&i);
  return(*this);
}

istream& istream::operator >>(unsigned char& c)
{
  int i;
  if(tie) tie->flush();
  fscanf(fin,"%u",&i);
  c = i;
  return(*this);
}
istream& istream::operator >>(unsigned short& s)
{
  if(tie) tie->flush();
  fscanf(fin,"%hu",&s);
  return(*this);
}
istream& istream::operator >>(unsigned int& i)
{
  if(tie) tie->flush();
  fscanf(fin,"%u",&i);
  return(*this);
}
istream& istream::operator >>(unsigned long& i)
{
  if(tie) tie->flush();
  fscanf(fin,"%lu",&i);
  return(*this);
}

istream& istream::operator >>(float& f)
{
  if(tie) tie->flush();
  fscanf(fin,"%g",&f);
  return(*this);
}

istream& istream::operator >>(double& d)
{
  if(tie) tie->flush();
  fscanf(fin,"%lg",&d);
  return(*this);
}

int istream::rdstate()
{
  int cx;
  if(!fin) return(1);
  cx = fgetc(fin);
  fseek(fin,-1,(1));
  if(EOF==cx) return(1);
  return(0);
}

/* instanciation of cin */
istream cin=istream(stdin);

/*********************************************************************
* iostream
*
*********************************************************************/
class iostream : public istream , public ostream {
 public:
  iostream(FILE *setfin) : istream(setfin), ostream(setfin) { }
  iostream(char *fname) : istream(fname), ostream(fname) { }
};


/*********************************************************************
* ofstream, ifstream 
*
*********************************************************************/

class fstream;

class ofstream : public ostream {
 public:
  ofstream(FILE* setfin) : ostream(setfin) { }
  ofstream(char* fname) : ostream(fname) { }
};

class ifstream : public istream {
 public:
  ifstream(FILE* setfin) : istream(setfin) { }
  ifstream(char* fname) : istream(fname) { }
};

class iofstream : public iostream {
 public:
  iofstream(FILE* setfin) : iostream(setfin) { }
  iofstream(char* fname) : iostream(fname) { }
};


ostream& flush(ostream& i) {i.flush(); return(i);}
ostream& endl(ostream& i) {return i << '\n' << flush;}
ostream& ends(ostream& i) {return i << '\0';}
istream& ws(istream& i) {
  fprintf(stderr,"Limitation: ws,WS manipurator not supported\n");
  return(i);
}
istream& WS(istream& i) {
  fprintf(stderr,"Limitation: ws,WS manipurator not supported\n");
  return(i);
}

#pragma endif

ostream& ostream::form(char *format ...) {
  char temp[1024];
  return(*this<<G__charformatter(0,temp,1024));
}

/*********************************************************************
* iostream manipurator emulation
*
*  Following description must be deleted when pointer to compiled 
* function is fully supported.
*********************************************************************/
struct G__CINT_IOFLAGS {
   G__CINT_IOFLAGS(int f = 0, int m = 0): flag(f), mask(m) {}
#pragma ifndef G__TMPLTIOS
   typedef ios ios_base;
#pragma endif
   int flag, mask;
};
class G__CINT_ENDL { int dmy; } endl;
class G__CINT_ENDS { int dmy; } ends;
class G__CINT_FLUSH { int dmy; } flush;
class G__CINT_ws { int dmy; } ws;
class G__CINT_WS { int dmy; } WS;



G__CINT_IOFLAGS hex(ios_base::hex, ios_base::basefield);;
G__CINT_IOFLAGS oct(ios_base::oct, ios_base::basefield);;
G__CINT_IOFLAGS dec(ios_base::dec, ios_base::basefield);;
G__CINT_IOFLAGS scientific(ios_base::scientific, ios_base::floatfield);;
G__CINT_IOFLAGS fixed(ios_base::fixed, ios_base::floatfield);;
/*
Better not, or "left" will become a CINT reserved variable.
G__DECL_IOFM(left,adjustfield);
G__DECL_IOFM(right,adjustfield);
G__DECL_IOFM(internal,adjustfield);
*/




G__CINT_IOFLAGS boolalpha(ios_base::boolalpha, ios_base::boolalpha);;
G__CINT_IOFLAGS showbase(ios_base::showbase, ios_base::showbase);;
G__CINT_IOFLAGS showpoint(ios_base::showpoint, ios_base::showpoint);;
G__CINT_IOFLAGS showpos(ios_base::showpos, ios_base::showpos);;
G__CINT_IOFLAGS skipws(ios_base::skipws, ios_base::skipws);;
G__CINT_IOFLAGS unitbuf(ios_base::unitbuf, ios_base::unitbuf);;
G__CINT_IOFLAGS uppercase(ios_base::uppercase, ios_base::uppercase);;


/*
class G__CINT_HEX { int dmy; } hex;
class G__CINT_DEC { int dmy; } dec;
class G__CINT_OCT { int dmy; } oct;
class G__CINT_OCT { int dmy; } showpoint;
class G__CINT_SCIENTIFIC { int dmy; } scientific;
class G__CINT_FIXED { int dmy; } fixed;
*/
class G__CINT_NOSUPPORT { int dmy; } ;
# 11 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream" 2
}
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/_iostream" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// include/_iostream

std::ostream& operator<<(std::ostream& ostr,std::G__CINT_ENDL& i)
 {return(std::endl(ostr));}
std::ostream& operator<<(std::ostream& ostr,std::G__CINT_ENDS& i)
 {return(std::ends(ostr));}
std::ostream& operator<<(std::ostream& ostr,std::G__CINT_FLUSH& i)
 {return(std::flush(ostr));}

std::istream& operator>>(std::istream& istr,std::G__CINT_ws& i)
 {return(std::ws(istr));}
std::istream& operator>>(std::istream& istr,std::G__CINT_WS& i)
 {return(std::WS(istr));}


std::ostream& operator<<(std::ostream& ostr,std::G__CINT_IOFLAGS& f) {
   ostr.setf(f.flag, f.mask);
  return ostr;
}
std::istream& operator>>(std::istream& istr,std::G__CINT_IOFLAGS& f) {
  istr.setf(f.flag, f.mask);
  return istr;
}

std::ostream& operator<<(std::ostream& ostr,std::G__CINT_NOSUPPORT& i) {
  fprintf(stderr,"Limitation: dec,hex,oct manipurator not supported\n");
  return(ostr);
}
std::istream& operator<<(std::istream& istr,std::G__CINT_NOSUPPORT& i) {
  fprintf(stderr,"Limitation: dec,hex,oct manipurator not supported\n");
  return(istr);
}


std::ostream& operator<<(std::ostream& ostr,long long i) {
  char buf[200];
#pragma ifndef G__TMPLTIOS
  if (ostr.flags() & ios::hex)
#pragma else
  if (ostr.flags() & ios_base::hex)
#pragma endif
     sprintf(buf,"%llx",i);
  else
     sprintf(buf,"%lld",i);
  ostr << buf ;
  return(ostr);
}
std::ostream& operator<<(std::ostream& ostr,unsigned long long i) {
  char buf[200];
#pragma ifndef G__TMPLTIOS
  if (ostr.flags() & ios::hex)
#pragma else
  if (ostr.flags() & ios_base::hex)
#pragma endif
     sprintf(buf,"%llx",i);
  else
     sprintf(buf,"%llu",i);
  ostr << buf ;
  return(ostr);
}
std::ostream& operator<<(std::ostream& ostr,long double i) {
  char buf[200];
  sprintf(buf,"%Lg",i);
  ostr << buf ;
  return(ostr);
}
std::istream& operator>>(std::istream& istr,long long &i) {
  char buf[200];
  istr >> buf ;
  sscanf(buf,"%lld",&i);
  return(istr);
}
std::istream& operator>>(std::istream& istr,unsigned long long &i) {
  char buf[200];
  istr >> buf ;
#pragma ifndef G__TMPLTIOS
  if (ostr.flags() & ios::hex)
#pragma else
  if (ostr.flags() & ios_base::hex)
#pragma endif
     sscanf(buf,"%llx",&i);
  else
     sscanf(buf,"%llu",&i);
  return(istr);
}
std::istream& operator>>(std::istream& istr,long double &i) {
  char buf[200];
  istr >> buf ;
  sscanf(buf,"%Lg",&i);
  return(istr);
}


// Value evaluation
//template<class T> int G__ateval(const T* x) {return(0);}
//template<class T> int G__ateval(const T& x) {return(0);}
int G__ateval(const char* const &x) {return(0);}
//int G__ateval(const void* const &x) {return(0);}
int G__ateval(double x) {return(0);}
int G__ateval(float x) {return(0);}
int G__ateval(bool x) {return(0);}
int G__ateval(char x) {return(0);}
int G__ateval(short x) {return(0);}
int G__ateval(int x) {return(0);}
int G__ateval(long x) {return(0);}
int G__ateval(unsigned char x) {return(0);}
int G__ateval(unsigned short x) {return(0);}
int G__ateval(unsigned int x) {return(0);}
int G__ateval(unsigned long x) {return(0);}
# 127 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/_iostream"
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iomanip.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * I/O manipulator header for iomanip.h
 ************************************************************************
 * Description:
 *  CINT IOMANIP header file
 ************************************************************************
 * Author                  Masaharu Goto 
 * Copyright(c) 1995~1999  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/




# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * I/O stream header file iostream.h
 ************************************************************************
 * Description:
 *  CINT iostream header file
 ************************************************************************
 * Copyright(c) 1995~1999  Masaharu Goto 
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
# 21 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iomanip.h" 2
# 59 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iomanip.h"
/*********************************************************************
* flat implementation of iomanip
*********************************************************************/

////////////////////////////////////////////////////////////////////////
class setw {
 public:
  int i;
  setw(int in) {i=in;}
} ;
ostream& operator<<(ostream& ostr,setw& i) {
 ostr.width(i.i);
 return(ostr);
}

////////////////////////////////////////////////////////////////////////
class setfill {
 public:
  int i;
  setfill(int in) {i=in;}
} ;
ostream& operator<<(ostream& ostr,setfill& i) {
 ostr.fill(i.i);
 return(ostr);
}

////////////////////////////////////////////////////////////////////////
class setiosflags {
 public:
  int i;
  setiosflags(int in) {i=in;}
} ;
ostream& operator<<(ostream& ostr,setiosflags& i) {
 ostr.setf(i.i);
 return(ostr);
}

////////////////////////////////////////////////////////////////////////
class resetiosflags {
 public:
  int i;
  resetiosflags(int in) {i=in;}
} ;
ostream& operator<<(ostream& ostr,resetiosflags& i) {
 ostr.unsetf(i.i);
 return(ostr);
}

////////////////////////////////////////////////////////////////////////
class setprecision {
 public:
  int i;
  setprecision(int in) {i=in;}
} ;
ostream& operator<<(ostream& ostr,setprecision& i) {
 ostr.precision(i.i);
 return(ostr);
}


////////////////////////////////////////////////////////////////////////
class setbase {
 public:
  int i;
  setbase(int in) {i=in;}
} ;
ostream& operator<<(ostream& ostr,setbase& i) {
#pragma ifndef G__TMPLTIOS
 if(8==i.i) ostr.flags(ios::oct);
 else if(10==i.i) ostr.flags(ios::dec);
 else if(16==i.i) ostr.flags(ios::hex);
#pragma else
 if(8==i.i) ostr.flags(ios_base::oct);
 else if(10==i.i) ostr.flags(ios_base::dec);
 else if(16==i.i) ostr.flags(ios_base::hex);
#pragma endif
 return(ostr);
}
istream& operator>>(istream& istr,setbase& i) {
#pragma ifndef G__TMPLTIOS
 if(8==i.i) istr.flags(ios::oct);
 else if(10==i.i) istr.flags(ios::dec);
 else if(16==i.i) istr.flags(ios::hex);
#pragma else
 if(8==i.i) istr.flags(ios_base::oct);
 else if(10==i.i) istr.flags(ios_base::dec);
 else if(16==i.i) istr.flags(ios_base::hex);
#pragma endif
 return(istr);
}

////////////////////////////////////////////////////////////////////////
# 161 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iomanip.h"
////////////////////////////////////////////////////////////////////////
# 127 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/_iostream" 2
# 12 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream" 2
# 26 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/string" 2


// for reverse_iterator
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <iterator.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/iterator

#pragma ifndef PREC_STL_ITERATOR
#pragma define PREC_STL_ITERATOR
#pragma link off global PREC_STL_ITERATOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from STL HP implementation 1994
// Imported from STL SGI implementation 1997 
// Imported from ANSI/ISO C++ draft Nov 1997
// Modified by Masaharu Goto
// May need improvement for the latest standard


////////////////////////////////////////////////////////////////////////
// iterator_tag
////////////////////////////////////////////////////////////////////////
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag {};
struct bidirectional_iterator_tag {};
struct random_access_iterator_tag {};

////////////////////////////////////////////////////////////////////////
// iterator template
////////////////////////////////////////////////////////////////////////
template <class T, class Distance> struct input_iterator {};
struct output_iterator {};
template <class T, class Distance> struct forward_iterator {};
template <class T, class Distance> struct bidirectional_iterator {};
template <class T, class Distance> struct random_access_iterator {};

#pragma link off class output_iterator;







////////////////////////////////////////////////////////////////////////
// iterator_category overloaded function
////////////////////////////////////////////////////////////////////////
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const input_iterator<T, Distance>&) {
    return input_iterator_tag();
}

inline output_iterator_tag iterator_category(const output_iterator&) {
    return output_iterator_tag();
}

#pragma link off function iterator_category(const output_iterator&);


template <class T, class Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<T, Distance>&) {
    return forward_iterator_tag();
}

template <class T, class Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<T, Distance>&) {
    return bidirectional_iterator_tag();
}

template <class T, class Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<T, Distance>&) {
    return random_access_iterator_tag();
}

template <class T>
inline random_access_iterator_tag
iterator_category(const T*) {
    return random_access_iterator_tag();
}


// iterator_traits, iterator and reverse_iterator template may not be
// needed for precompiled library interface 

////////////////////////////////////////////////////////////////////////
// iterator_traits
////////////////////////////////////////////////////////////////////////

template <class Iterator>
struct iterator_traits {
  typedef typename Iterator::iterator_category iterator_category;
  typedef typename Iterator::value_type value_type;
  typedef typename Iterator::difference_type difference_type;
  typedef typename Iterator::pointer pointer;
  typedef typename Iterator::reference reference;
};

// template partial specialization, implement in cint5.15.14 1587
template <class T>
struct iterator_traits<T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef T& reference;
};

// incomplete implementation in cint5.15.14 1587, need some fix
// iterator_traits<const int*> is changed as iterator_traits<const int* const>
// or something, but cint5.15.14 can not handle this well
template <class T>
struct iterator_traits<const T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef const T* pointer;
  typedef const T& reference;
};

////////////////////////////////////////////////////////////////////////
// iterator
////////////////////////////////////////////////////////////////////////
template<class Category, class T, class Distance = ptrdiff_t,
         class Pointer = T*, class Reference = T&>
struct iterator {
  typedef T value_type;
  typedef Distance difference_type;
  typedef Pointer pointer;
  typedef Reference reference;
  typedef Category iterator_category;
};


////////////////////////////////////////////////////////////////////////
// reverse_iterator
////////////////////////////////////////////////////////////////////////






template <class Iterator>
class reverse_iterator
# 166 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
{




 public:
# 181 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
   typedef Iterator::pointer pointer;
   typedef Iterator::reference reference;
   typedef ptrdiff_t difference_type;


   reverse_iterator();
   //reverse_iterator(Iterator x);



   Iterator base() const; // explicit
   reference operator*() const;
   pointer operator->() const;
   reverse_iterator& operator++();
   reverse_iterator operator++(int);
   reverse_iterator& operator--();
   reverse_iterator operator--(int);
   reverse_iterator operator+ (difference_type n) const;
   reverse_iterator& operator+=(difference_type n);
   reverse_iterator operator- (difference_type n) const;
   reverse_iterator& operator-=(difference_type n);
   reference operator[](difference_type n) const;
};
# 932 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
// for g++ 3.1,3.2
namespace __gnu_cxx
{
  // This iterator adapter is 'normal' in the sense that it does not
  // change the semantics of any of the operators of its iterator
  // parameter.  Its primary purpose is to convert an iterator that is
  // not a class, e.g. a pointer, into an iterator that is a class.
  // The _Container parameter exists solely so that different containers
  // using this template can instantiate different types, even if the
  // _Iterator parameter is the same.
  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
      : public iterator<typename iterator_traits<_Iterator>::iterator_category,
                        typename iterator_traits<_Iterator>::value_type,
                        typename iterator_traits<_Iterator>::difference_type,
                        typename iterator_traits<_Iterator>::pointer,
                        typename iterator_traits<_Iterator>::reference>
    {
    protected:
      _Iterator _M_current;

    public:
      typedef typename iterator_traits<_Iterator>::difference_type
                    difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

      __normal_iterator() : _M_current(_Iterator()) { }

      explicit
      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

      // Allow iterator to const_iterator conversion
      template<typename _Iter>
      inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
 : _M_current(__i.base()) { }

      // Forward iterator requirements
      reference
      operator*() const { return *_M_current; }

      pointer
      operator->() const { return _M_current; }

      __normal_iterator&
      operator++() { ++_M_current; return *this; }

      __normal_iterator
      operator++(int) { return __normal_iterator(_M_current++); }

      // Bidirectional iterator requirements
      __normal_iterator&
      operator--() { --_M_current; return *this; }

      __normal_iterator
      operator--(int) { return __normal_iterator(_M_current--); }

      // Random access iterator requirements
      reference
      operator[](const difference_type& __n) const
      { return _M_current[__n]; }

      __normal_iterator&
      operator+=(const difference_type& __n)
      { _M_current += __n; return *this; }

      __normal_iterator
      operator+(const difference_type& __n) const
      { return __normal_iterator(_M_current + __n); }

      __normal_iterator&
      operator-=(const difference_type& __n)
      { _M_current -= __n; return *this; }

      __normal_iterator
      operator-(const difference_type& __n) const
      { return __normal_iterator(_M_current - __n); }

      const _Iterator&
      base() const { return _M_current; }
    };

  // Note: In what follows, the left- and right-hand-side iterators are
  // allowed to vary in types (conceptually in cv-qualification) so that
  // comparaison between cv-qualified and non-cv-qualified iterators be
  // valid.  However, the greedy and unfriendly operators in std::rel_ops
  // will make overload resolution ambiguous (when in scope) if we don't
  // provide overloads whose operands are of the same type.  Can someone
  // remind me what generic programming is about? -- Gaby

  // Forward iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  // Random access iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  // _GLIBCPP_RESOLVE_LIB_DEFECTS
  // According to the resolution of DR179 not only the various comparison
  // operators but also operator- must accept mixed iterator/const_iterator
  // parameters.
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
     const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
} // namespace __gnu_cxx







#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 2
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/iterator" 2
}
# 30 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/string" 2
# 38 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/string"
//////////////////////////////////////////////////////////////////////////
class string {
 public:
  typedef char value_type;
  typedef char* pointer;
  typedef const char* const_pointer;
  typedef char& reference;
  typedef const char& const_reference;
  typedef ptrdiff_t difference_type;
  typedef size_t size_type;
  typedef int traits_type;
# 62 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/string"
  class iterator {
   public:
      iterator();
      explicit iterator(const pointer& __i) ;
      // Allow iterator to const_iterator conversion
      template<typename _Iter> inline iterator(const iterator& __i);

      // Forward iterator requirements
      reference operator*() const ;
      pointer operator->() const ;
      iterator& operator++();
      iterator operator++(int) ;

      // Bidirectional iterator requirements
      iterator& operator--() ;
      iterator operator--(int) ;

      // Random access iterator requirements
      reference operator[](const difference_type& __n) const;
      iterator& operator+=(const difference_type& __n);
      iterator operator+(const difference_type& __n) const;
      iterator& operator-=(const difference_type& __n);
      iterator operator-(const difference_type& __n) const;
      const pointer& base() const ;
  };
  typedef const iterator const_iterator;
# 183 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/string"
   typedef std::reverse_iterator<iterator> reverse_iterator;
   typedef std::reverse_iterator<const_iterator> const_reverse_iterator;



  static const size_t npos = -1;



  string() ;
  //string(size_t size,capacity cap) ;
  string(const string& str) ;
  string(const string& str,size_t pos,size_t n) ;
  string(const char* s,size_t n) ;
  string(const char* s) ;
  string(size_t rep, char c);
  //string(const vector<char>& vec);
  ~string() ;
  string& operator=(const string& str);
  string& operator=(const char* s);
  string& operator=(char c);
  string& operator+=(const string& rhs);
  string& operator+=(const char* s);
  string& operator+=(char c);
  //vector<char> operator vector<char>(void) const;
  string& append(const string& str);
  string& append(const string& str,size_t pos,size_t n);
  string& append(const char* s,size_t n);
  string& append(const char* s);
  string& append(size_t rep, char c);
  string& assign(const string& str);
  string& assign(const string& str,size_t pos,size_t n);
  string& assign(const char* s,size_t n);
  string& assign(const char* s);
  string& assign(size_t rep, char c);
  string& insert(size_t pos1,const string& str);
  string& insert(size_t pos1,const string& str,size_t pos2,size_t n);
  string& insert(size_t pos,const char* s,size_t n);
  string& insert(size_t pos,const char* s);
  string& insert(size_t pos,size_t rep,char c);
  //string& remove(size_t pos=0,size_t n=npos);
  string& replace(size_t pos1,size_t n1,const string& str);
  string& replace(size_t pos1,size_t n1,const string& str,size_t pos2,size_t n2);
  string& replace(size_t pos,size_t n1,const char* s,size_t n2);
  string& replace(size_t pos,size_t n1,const char* s);
  string& replace(size_t pos,size_t n,size_t rep,char c);
  //char get_at(size_t pos) const;
  //void put_at(size_t pos,char c);
  const char& operator[](size_t pos) const;
  char& operator[](size_t pos);
  const char& at(size_t pos) const;
  char& at(size_t pos);
  const char* c_str(void) const;
  const char* data(void) const;
  size_t length(void) const;
  void resize(size_t n,char c);
  void resize(size_t n);
  int size();
  //size_t reserve(void) const;
  void reserve(size_t res_arg);
  size_t copy(char* s,size_t n,size_t pos=0) /* const */;
  size_t find(const string& str,size_t pos=0) const;
  size_t find(const char* s,size_t pos,size_t n) const;
  size_t find(const char* s,size_t pos=0) const;
  size_t find(char c,size_t pos=0) const;
  size_t rfind(const string& str,size_t pos=npos) const;
  size_t rfind(const char* s,size_t pos,size_t n) const;
  size_t rfind(const char* s,size_t pos=npos) const;
  size_t rfind(char c,size_t pos=npos) const;
  size_t find_first_of(const string& str,size_t pos=0) const;
  size_t find_first_of(const char* s,size_t pos,size_t n) const;
  size_t find_first_of(const char* s,size_t pos=0) const;
  size_t find_first_of(char c,size_t pos=0) const;
  size_t find_last_of(const string& str,size_t pos=npos) const;
  size_t find_last_of(const char* s,size_t pos,size_t n) const;
  size_t find_last_of(const char* s,size_t pos=npos) const;
  size_t find_last_of(char c,size_t pos=npos) const;
  size_t find_first_not_of(const string& str,size_t pos=0) const;
  size_t find_first_not_of(const char* s,size_t pos,size_t n) const;
  size_t find_first_not_of(const char* s,size_t pos=0) const;
  size_t find_first_not_of(char c,size_t pos=0) const;
  size_t find_last_not_of(const string& str,size_t pos=npos) const;
  size_t find_last_not_of(const char* s,size_t pos,size_t n) const;
  size_t find_last_not_of(const char* s,size_t pos=npos) const;
  size_t find_last_not_of(char c,size_t pos=npos) const;
  string substr(size_t pos=0,size_t n=npos) const;
  int compare(const string& str) const;
  //int compare(size_type pos1,size_type n1,const string& str,size_type n2) const;
  int compare(const char* s) const ;
  //int compare(size_type pos1,size_type n1,const char* s,size_type n2=npos)const;
  //operator char*() ;

  string& erase(size_t pos=0, size_t n=npos);
  iterator erase(iterator pos);
  iterator erase(iterator first, iterator last);
# 291 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/string"
};

bool operator==(const string& a,const string& b) ;
bool operator!=(const string& a,const string& b) ;
bool operator<(const string& a,const string& b) ;
bool operator>(const string& a,const string& b) ;
bool operator<=(const string& a,const string& b) ;
bool operator>=(const string& a,const string& b) ;
string operator+(const string& a,const string& b) ;
string operator+(char a,const string& b) ;
string operator+(const string& a,char b) ;

//#ifdef G__ROOT
bool operator==(const string& a,const char *b) ;
bool operator!=(const string& a,const char *b) ;
bool operator<(const string& a,const char *b) ;
bool operator>(const string& a,const char *b) ;
bool operator<=(const string& a,const char *b) ;
bool operator>=(const string& a,const char *b) ;
string operator+(const string& a,const char *b) ;

bool operator==(const char *a,const string& b) ;
bool operator!=(const char *a,const string& b) ;
bool operator<(const char *a,const string& b) ;
bool operator>(const char *a,const string& b) ;
bool operator<=(const char *a,const string& b) ;
bool operator>=(const char *a,const string& b) ;
string operator+(const char *a,const string& b) ;
//#endif

typedef string cstring;

void swap(string& lhs,string& rhs);
istream& operator>>(istream& is, string& st);
ostream& operator<<(ostream& is, const string& st);
istream& getline(istream& is,string& st);
istream& getline(istream& is,string& st,char delim);



bool operator==(const string::iterator& _Left, const string::iterator& _Right);
bool operator!=(const string::iterator& _Left, const string::iterator& _Right);


#pragma endif
# 20 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_string" 2
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/string" 2
}
# 26 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSchemaHelper.h" 2

namespace ROOT
{
   struct TSchemaHelper
   {
      TSchemaHelper(): fTarget(), fSourceClass(),
       fSource(), fCode(), fVersion(), fChecksum(),
       fInclude(), fEmbed(kTRUE), fFunctionPtr( 0 ),
       fAttributes() {}
      std::string fTarget;
      std::string fSourceClass;
      std::string fSource;
      std::string fCode;
      std::string fVersion;
      std::string fChecksum;
      std::string fInclude;
      Bool_t fEmbed;
      void* fFunctionPtr;
      std::string fAttributes;

      TSchemaHelper(const TSchemaHelper &tsh) :
       fTarget(tsh.fTarget), fSourceClass(tsh.fSourceClass),
       fSource(tsh.fSource), fCode(tsh.fCode), fVersion(tsh.fVersion),fChecksum(tsh.fChecksum),
       fInclude(tsh.fInclude), fEmbed(tsh.fEmbed), fFunctionPtr(tsh.fFunctionPtr),
       fAttributes(tsh.fAttributes) {}

      TSchemaHelper& operator=(const TSchemaHelper &) {return *this;} // Not implemented
   };
}
# 18 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGenericClassInfo.h" 2
//#endif
//#ifndef ROOT_Rtypes
//#inlcude "Rtypes.h"
//#endif

// Forward declarations
class TVirtualIsAProxy;
//class TClass;
//class TClassStreamer;
//class TVirtualCollectionProxy;
//class TCollectionProxyInfo;


namespace ROOT {

   class TCollectionProxyInfo;

   class TGenericClassInfo {
      // This class in not inlined because it is used is non time critical
      // section (the dictionaries) and inline would lead to too much
      // repetition of the code (once per class!).

      const TInitBehavior *fAction;
      TClass *fClass;
      const char *fClassName;
      const char *fDeclFileName;
      Int_t fDeclFileLine;
      VoidFuncPtr_t fDictionary;
      const type_info &fInfo;
      const char *fImplFileName;
      Int_t fImplFileLine;
      TVirtualIsAProxy *fIsA;
      ShowMembersFunc_t fShowMembers;
      Int_t fVersion;
      MergeFunc_t fMerge;
      ResetAfterMergeFunc_t fResetAfterMerge;
      NewFunc_t fNew;
      NewArrFunc_t fNewArray;
      DelFunc_t fDelete;
      DelArrFunc_t fDeleteArray;
      DesFunc_t fDestructor;
      DirAutoAdd_t fDirAutoAdd;
      TClassStreamer *fStreamer;
      ClassStreamerFunc_t fStreamerFunc;
      TVirtualCollectionProxy *fCollectionProxy;
      Int_t fSizeof;
      TCollectionProxyInfo *fCollectionProxyInfo;
      TCollectionProxyInfo *fCollectionStreamerInfo;
      std::vector<ROOT::TSchemaHelper> fReadRules;
      std::vector<ROOT::TSchemaHelper> fReadRawRules;

   public:
      TGenericClassInfo(const char *fullClassname,
                       const char *declFileName, Int_t declFileLine,
                       const type_info &info, const TInitBehavior *action,
                       ShowMembersFunc_t showmembers, VoidFuncPtr_t dictionary,
                       TVirtualIsAProxy *isa, Int_t pragmabits, Int_t sizof);

      TGenericClassInfo(const char *fullClassname, Int_t version,
                       const char *declFileName, Int_t declFileLine,
                       const type_info &info, const TInitBehavior *action,
                       ShowMembersFunc_t showmembers, VoidFuncPtr_t dictionary,
                       TVirtualIsAProxy *isa, Int_t pragmabits, Int_t sizof);

      TGenericClassInfo(const char *fullClassname, Int_t version,
                       const char *declFileName, Int_t declFileLine,
                       const type_info &info, const TInitBehavior *action,
                       VoidFuncPtr_t dictionary,
                       TVirtualIsAProxy *isa, Int_t pragmabits, Int_t sizof);

      TGenericClassInfo(const char *fullClassname, Int_t version,
                        const char *declFileName, Int_t declFileLine,
                        const TInitBehavior *action,
                        VoidFuncPtr_t dictionary, Int_t pragmabits);

      void Init(Int_t pragmabits);
      ~TGenericClassInfo();

      const TInitBehavior &GetAction() const;
      TClass *GetClass();
      const char *GetClassName() const;
      TCollectionProxyInfo *GetCollectionProxyInfo() const;
      TCollectionProxyInfo *GetCollectionStreamerInfo() const;
      const char *GetDeclFileName() const;
      Int_t GetDeclFileLine() const;
      DelFunc_t GetDelete() const;
      DelArrFunc_t GetDeleteArray() const;
      DesFunc_t GetDestructor() const;
      DirAutoAdd_t GetDirectoryAutoAdd() const;
      const char *GetImplFileName();
      Int_t GetImplFileLine();
      const type_info &GetInfo() const;
      TVirtualIsAProxy *GetIsA() const;
      NewFunc_t GetNew() const;
      NewArrFunc_t GetNewArray() const;
      const std::vector<ROOT::TSchemaHelper> &GetReadRawRules() const;
      const std::vector<ROOT::TSchemaHelper> &GetReadRules() const;
      ShowMembersFunc_t GetShowMembers() const;
      Int_t GetVersion() const;

      TClass *IsA(const void *obj);

      Short_t AdoptStreamer(TClassStreamer*);
      Short_t AdoptCollectionProxy(TVirtualCollectionProxy*);
      void AdoptCollectionProxyInfo(TCollectionProxyInfo*);
      void AdoptCollectionStreamerInfo(TCollectionProxyInfo*);
      Int_t SetDeclFile(const char *file, Int_t line);
      void SetDelete(DelFunc_t deleteFunc);
      void SetDeleteArray(DelArrFunc_t deleteArrayFunc);
      void SetDestructor(DesFunc_t destructorFunc);
      void SetDirectoryAutoAdd(DirAutoAdd_t dirAutoAdd);
      void SetFromTemplate();
      Int_t SetImplFile(const char *file, Int_t line);
      void SetMerge(MergeFunc_t);
      void SetResetAfterMerge(ResetAfterMergeFunc_t);
      void SetNew(NewFunc_t newFunc);
      void SetNewArray(NewArrFunc_t newArrayFunc);
      void SetReadRawRules( const std::vector<ROOT::TSchemaHelper>& rules );
      void SetReadRules( const std::vector<ROOT::TSchemaHelper>& rules );
      Short_t SetStreamer(ClassStreamerFunc_t);
      void SetStreamerFunc(ClassStreamerFunc_t);
      Short_t SetVersion(Short_t version);

      //   protected:
   private:
      void CreateRuleSet( std::vector<ROOT::TSchemaHelper>& vect, Bool_t ProcessReadRules );
      TGenericClassInfo(const TGenericClassInfo&); // Not implemented
      TGenericClassInfo& operator=(const TGenericClassInfo&); // Not implemented

   private:
      TGenericClassInfo();

   };

}
# 268 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 2


// Common part of ClassDef definition.
// DeclFileLine() is not part of it since CINT uses that as trigger for
// the class comment string.
# 289 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h"
// Version without any virtual functions.
# 366 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h"
// Macro for Namespace
# 384 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h"
//---- ClassDefT macros for templates with one template argument ---------------
// ClassDefT  corresponds to ClassDef
// ClassDefT2 goes in the same header as ClassDefT but must be
//            outside the class scope
// ClassImpT  corresponds to ClassImp


// This ClassDefT is stricly redundant and is kept only for
// backward compatibility. Using #define ClassDef ClassDefT is confusing
// the CINT parser.
# 438 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h"
//---- ClassDefT macros for templates with two template arguments --------------
// ClassDef2T2 goes in the same header as ClassDefT but must be
//             outside the class scope
// ClassImp2T  corresponds to ClassImpT





//---- ClassDefT macros for templates with three template arguments ------------
// ClassDef3T2 goes in the same header as ClassDefT but must be
//             outside the class scope
// ClassImp3T  corresponds to ClassImpT





//---- Macro to set the class version of non instrumented classes --------------
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TStorage.h" 1
// @(#)root/base:$Id: TStorage.h 27683 2009-03-03 20:15:49Z pcanal $
// Author: Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TStorage                                                             //
//                                                                      //
// Storage manager.                                                     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





typedef void (*FreeHookFun_t)(void*, void *addr, size_t);
typedef void *(*ReAllocFun_t)(void*, size_t);
typedef void *(*ReAllocCFun_t)(void*, size_t, size_t);
typedef char *(*ReAllocCharFun_t)(char*, size_t, size_t);


class TStorage {

private:
   static ULong_t fgHeapBegin; // begin address of heap
   static ULong_t fgHeapEnd; // end address of heap
   static size_t fgMaxBlockSize; // largest block allocated
   static FreeHookFun_t fgFreeHook; // function called on free
   static void *fgFreeHookData; // data used by this function
   static ReAllocFun_t fgReAllocHook; // custom ReAlloc
   static ReAllocCFun_t fgReAllocCHook; // custom ReAlloc with length check
   static Bool_t fgHasCustomNewDelete; // true if using ROOT's new/delete

public:
   virtual ~TStorage() { }

   static ULong_t GetHeapBegin();
   static ULong_t GetHeapEnd();
   static FreeHookFun_t GetFreeHook();
   static void *GetFreeHookData();
   static size_t GetMaxBlockSize();
   static void *Alloc(size_t size);
   static void Dealloc(void *ptr);
   static void *ReAlloc(void *vp, size_t size);
   static void *ReAlloc(void *vp, size_t size, size_t oldsize);
   static char *ReAllocChar(char *vp, size_t size, size_t oldsize);
   static Int_t *ReAllocInt(Int_t *vp, size_t size, size_t oldsize);
   static void *ObjectAlloc(size_t size);
   static void *ObjectAlloc(size_t size, void *vp);
   static void ObjectDealloc(void *vp);
   static void ObjectDealloc(void *vp, void *ptr);

   static void EnterStat(size_t size, void *p);
   static void RemoveStat(void *p);
   static void PrintStatistics();
   static void SetMaxBlockSize(size_t size);
   static void SetFreeHook(FreeHookFun_t func, void *data);
   static void SetReAllocHooks(ReAllocFun_t func1, ReAllocCFun_t func2);
   static void SetCustomNewDelete();
   static void EnableStatistics(int size= -1, int ix= -1);

   static Bool_t HasCustomNewDelete();

   // only valid after call to a TStorage allocating method
   static void AddToHeap(ULong_t begin, ULong_t end);
   static Bool_t IsOnHeap(void *p);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TStorage::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TStorage::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TStorage.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 80; } //Storage manager class
};


inline void TStorage::AddToHeap(ULong_t begin, ULong_t end)
   { if (begin < fgHeapBegin) fgHeapBegin = begin;
     if (end > fgHeapEnd) fgHeapEnd = end; }

inline Bool_t TStorage::IsOnHeap(void *p)
   { return (ULong_t)p >= fgHeapBegin && (ULong_t)p < fgHeapEnd; }

inline size_t TStorage::GetMaxBlockSize() { return fgMaxBlockSize; }

inline void TStorage::SetMaxBlockSize(size_t size) { fgMaxBlockSize = size; }

inline FreeHookFun_t TStorage::GetFreeHook() { return fgFreeHook; }
# 35 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVersionCheck.h" 1
// @(#)root/base:$Id: TVersionCheck.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Fons Rademakers   9/5/2007

/*************************************************************************
 * Copyright (C) 1995-2007, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TVersionCheck                                                        //
//                                                                      //
// Used to check if the shared library or plugin is compatible with     //
// the current version of ROOT.                                         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TVersionCheck {
public:
   TVersionCheck(int versionCode); // implemented in TSystem.cxx
};
# 38 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Riosfwd.h" 1
// @(#)root/base:$Id: Riosfwd.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Fons Rademakers   23/1/02

/*************************************************************************
 * Copyright (C) 1995-2002, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Riosfwd                                                              //
//                                                                      //
// This headers is only supposed to be used in header files.            //
// Never in sources, in source files use the companion Riostream.h.     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 33 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Riosfwd.h"
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iosfwd" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iosfwd.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/


# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * I/O stream header file iostream.h
 ************************************************************************
 * Description:
 *  CINT iostream header file
 ************************************************************************
 * Copyright(c) 1995~1999  Masaharu Goto 
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
# 11 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iosfwd.h" 2
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iosfwd" 2
}
# 34 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Riosfwd.h" 2

using std::istream;
using std::ostream;
using std::fstream;
using std::ifstream;
using std::ofstream;
# 41 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 2

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/stdarg.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
/****************************************************************
* stdarg.h
*****************************************************************/



struct va_list {
  void* libp;
  int ip;
} ;
# 43 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 2





class TList;
class TBrowser;
class TBuffer;
class TObjArray;
class TMethod;
class TTimer;


class TObject {

private:
   UInt_t fUniqueID; //object unique identifier
   UInt_t fBits; //bit field status word

   static Long_t fgDtorOnly; //object for which to call dtor only (i.e. no delete)
   static Bool_t fgObjectStat; //if true keep track of objects in TObjectTable

protected:
   void MakeZombie() { fBits |= kZombie; }
   virtual void DoError(int level, const char *location, const char *fmt, va_list va) const;

public:
   //----- Global bits (can be set for any object and should not be reused).
   //----- Bits 0 - 13 are reserved as global bits. Bits 14 - 23 can be used
   //----- in different class hierarchies (make sure there is no overlap in
   //----- any given hierarchy).
   enum EStatusBits {
      kCanDelete = (1ULL << (0)), // if object in a list can be deleted
      kMustCleanup = (1ULL << (3)), // if object destructor must call RecursiveRemove()
      kObjInCanvas = (1ULL << (3)), // for backward compatibility only, use kMustCleanup
      kIsReferenced = (1ULL << (4)), // if object is referenced by a TRef or TRefArray
      kHasUUID = (1ULL << (5)), // if object has a TUUID (its fUniqueID=UUIDNumber)
      kCannotPick = (1ULL << (6)), // if object in a pad cannot be picked
      kNoContextMenu = (1ULL << (8)), // if object does not want context menu
      kInvalidObject = (1ULL << (13)) // if object ctor succeeded but object should not be used
   };

   //----- Private bits, clients can only test but not change them
   enum {
      kIsOnHeap = 0x01000000, // object is on heap
      kNotDeleted = 0x02000000, // object has not been deleted
      kZombie = 0x04000000, // object ctor failed
      kBitMask = 0x00ffffff
   };

   //----- Write() options
   enum {
      kSingleKey = (1ULL << (0)), // write collection with single key
      kOverwrite = (1ULL << (1)), // overwrite existing object with same name
      kWriteDelete = (1ULL << (2)) // write object, then delete previous key with same name
   };

   TObject();
   TObject(const TObject &object);
   TObject &operator=(const TObject &rhs);
   virtual ~TObject();

   virtual void AppendPad(Option_t *option="");
   virtual void Browse(TBrowser *b);
   virtual const char *ClassName() const;
   virtual void Clear(Option_t * /*option*/ ="") { }
   virtual TObject *Clone(const char *newname="") const;
   virtual Int_t Compare(const TObject *obj) const;
   virtual void Copy(TObject &object) const;
   virtual void Delete(Option_t *option=""); // *MENU*
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual void Draw(Option_t *option="");
   virtual void DrawClass() const; // *MENU*
   virtual TObject *DrawClone(Option_t *option="") const; // *MENU*
   virtual void Dump() const; // *MENU*
   virtual void Execute(const char *method, const char *params, Int_t *error=0);
   virtual void Execute(TMethod *method, TObjArray *params, Int_t *error=0);
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   virtual TObject *FindObject(const char *name) const;
   virtual TObject *FindObject(const TObject *obj) const;
   virtual Option_t *GetDrawOption() const;
   virtual UInt_t GetUniqueID() const;
   virtual const char *GetName() const;
   virtual const char *GetIconName() const;
   virtual Option_t *GetOption() const { return ""; }
   virtual char *GetObjectInfo(Int_t px, Int_t py) const;
   virtual const char *GetTitle() const;
   virtual Bool_t HandleTimer(TTimer *timer);
   virtual ULong_t Hash() const;
   virtual Bool_t InheritsFrom(const char *classname) const;
   virtual Bool_t InheritsFrom(const TClass *cl) const;
   virtual void Inspect() const; // *MENU*
   virtual Bool_t IsFolder() const;
   virtual Bool_t IsEqual(const TObject *obj) const;
   virtual Bool_t IsSortable() const { return kFALSE; }
           Bool_t IsOnHeap() const { return TestBit(kIsOnHeap); }
           Bool_t IsZombie() const { return TestBit(kZombie); }
   virtual Bool_t Notify();
   virtual void ls(Option_t *option="") const;
   virtual void Paint(Option_t *option="");
   virtual void Pop();
   virtual void Print(Option_t *option="") const;
   virtual Int_t Read(const char *name);
   virtual void RecursiveRemove(TObject *obj);
   virtual void SaveAs(const char *filename="",Option_t *option="") const; // *MENU*
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetDrawOption(Option_t *option=""); // *MENU*
   virtual void SetUniqueID(UInt_t uid);
   virtual void UseCurrentStyle();
   virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0);
   virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0) const;

   //----- operators
   void *operator new(size_t sz) { return TStorage::ObjectAlloc(sz); }
   void *operator new[](size_t sz) { return TStorage::ObjectAlloc(sz); }
   void *operator new(size_t sz, void *vp) { return TStorage::ObjectAlloc(sz, vp); }
   void *operator new[](size_t sz, void *vp) { return TStorage::ObjectAlloc(sz, vp); }
   void operator delete(void *ptr);
   void operator delete[](void *ptr);

   void operator delete(void *ptr, void *vp);
   void operator delete[](void *ptr, void *vp);


   //----- bit manipulation
   void SetBit(UInt_t f, Bool_t set);
   void SetBit(UInt_t f) { fBits |= f & kBitMask; }
   void ResetBit(UInt_t f) { fBits &= ~(f & kBitMask); }
   Bool_t TestBit(UInt_t f) const { return (Bool_t) ((fBits & f) != 0); }
   Int_t TestBits(UInt_t f) const { return (Int_t) (fBits & f); }
   void InvertBit(UInt_t f) { fBits ^= f & kBitMask; }

   //---- error handling
   virtual void Info(const char *method, const char *msgfmt, ...) const



   ;
   virtual void Warning(const char *method, const char *msgfmt, ...) const



   ;
   virtual void Error(const char *method, const char *msgfmt, ...) const



   ;
   virtual void SysError(const char *method, const char *msgfmt, ...) const



   ;
   virtual void Fatal(const char *method, const char *msgfmt, ...) const



   ;

   void AbstractMethod(const char *method) const;
   void MayNotUse(const char *method) const;
   void Obsolete(const char *method, const char *asOfVers, const char *removedFromVers) const;

   //---- static functions
   static Long_t GetDtorOnly();
   static void SetDtorOnly(void *obj);
   static Bool_t GetObjectStat();
   static void SetObjectStat(Bool_t stat);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TObject::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TObject::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 212; } //Basic ROOT object
};

// Global bits (can be set for any object and should not be reused).
// Only here for backward compatibility reasons.
// For detailed description see TObject::EStatusBits above.
enum EObjBits {
   kCanDelete = TObject::kCanDelete,
   kMustCleanup = TObject::kMustCleanup,
   kObjInCanvas = TObject::kObjInCanvas,
   kIsReferenced = TObject::kIsReferenced,
   kHasUUID = TObject::kHasUUID,
   kCannotPick = TObject::kCannotPick,
   kNoContextMenu = TObject::kNoContextMenu,
   kInvalidObject = TObject::kInvalidObject
};


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBuffer.h" 1
// @(#)root/base:$Id: TBuffer.h 40872 2011-09-13 21:33:33Z pcanal $
// Author: Rene Brun, Philippe Canal, Fons Rademakers   04/05/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TBuffer                                                              //
//                                                                      //
// Buffer base class used for serializing objects.                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TVirtualStreamerInfo;
class TStreamerElement;
class TClass;
class TString;
class TProcessID;
class TClonesArray;
class TRefTable;
class TVirtualArray;
namespace TStreamerInfoActions {
   class TActionSequence;
}

class TBuffer : public TObject {

protected:
   typedef std::vector<TVirtualArray*> CacheList_t;

   Bool_t fMode; //Read or write mode
   Int_t fVersion; //Buffer format version
   Int_t fBufSize; //Size of buffer
   char *fBuffer; //Buffer used to store objects
   char *fBufCur; //Current position in buffer
   char *fBufMax; //End of buffer
   TObject *fParent; //Pointer to parent object owning this buffer
   ReAllocCharFun_t fReAllocFunc; //! Realloc function to be used when extending the buffer.
   CacheList_t fCacheStack; //Stack of pointers to the cache where to temporarily store the value of 'missing' data members

   // Default ctor
   TBuffer() : TObject(), fMode(0), fVersion(0), fBufSize(0), fBuffer(0),
     fBufCur(0), fBufMax(0), fParent(0), fReAllocFunc(0), fCacheStack(0,(TVirtualArray*)0) {}

   // TBuffer objects cannot be copied or assigned
   TBuffer(const TBuffer &); // not implemented
   void operator=(const TBuffer &); // not implemented

   Int_t Read(const char *name) { return TObject::Read(name); }
   Int_t Write(const char *name, Int_t opt, Int_t bufs)
                              { return TObject::Write(name, opt, bufs); }
   Int_t Write(const char *name, Int_t opt, Int_t bufs) const
                              { return TObject::Write(name, opt, bufs); }

public:
   enum EMode { kRead = 0, kWrite = 1 };
   enum { kIsOwner = (1ULL << (16)) }; //if set TBuffer owns fBuffer
   enum { kCannotHandleMemberWiseStreaming = (1ULL << (17))}; //if set TClonesArray should not use member wise streaming
   enum { kInitialSize = 1024, kMinimalSize = 128 };

   TBuffer(EMode mode);
   TBuffer(EMode mode, Int_t bufsiz);
   TBuffer(EMode mode, Int_t bufsiz, void *buf, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0);
   virtual ~TBuffer();

   Int_t GetBufferVersion() const { return fVersion; }
   Bool_t IsReading() const { return (fMode & kWrite) == 0; }
   Bool_t IsWriting() const { return (fMode & kWrite) != 0; }
   void SetReadMode();
   void SetWriteMode();
   void SetBuffer(void *buf, UInt_t bufsiz = 0, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0);
   ReAllocCharFun_t GetReAllocFunc() const;
   void SetReAllocFunc(ReAllocCharFun_t reallocfunc = 0);
   void SetBufferOffset(Int_t offset = 0) { fBufCur = fBuffer+offset; }
   void SetParent(TObject *parent);
   TObject *GetParent() const;
   char *Buffer() const { return fBuffer; }
   Int_t BufferSize() const { return fBufSize; }
   void DetachBuffer() { fBuffer = 0; }
   Int_t Length() const { return (Int_t)(fBufCur - fBuffer); }
   void Expand(Int_t newsize, Bool_t copy = kTRUE); // expand buffer to newsize
   void AutoExpand(Int_t size_needed); // expand buffer to newsize

   virtual Bool_t CheckObject(const TObject *obj) = 0;
   virtual Bool_t CheckObject(const void *obj, const TClass *ptrClass) = 0;

   virtual Int_t ReadBuf(void *buf, Int_t max) = 0;
   virtual void WriteBuf(const void *buf, Int_t max) = 0;

   virtual char *ReadString(char *s, Int_t max) = 0;
   virtual void WriteString(const char *s) = 0;

   virtual Int_t GetVersionOwner() const = 0;
   virtual Int_t GetMapCount() const = 0;
   virtual void GetMappedObject(UInt_t tag, void* &ptr, TClass* &ClassPtr) const = 0;
   virtual void MapObject(const TObject *obj, UInt_t offset = 1) = 0;
   virtual void MapObject(const void *obj, const TClass *cl, UInt_t offset = 1) = 0;
   virtual void Reset() = 0;
   virtual void InitMap() = 0;
   virtual void ResetMap() = 0;
   virtual void SetReadParam(Int_t mapsize) = 0;
   virtual void SetWriteParam(Int_t mapsize) = 0;

   virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss) = 0;
   virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const char *classname) = 0;
   virtual void SetByteCount(UInt_t cntpos, Bool_t packInVersion = kFALSE)= 0;

   virtual void SkipVersion(const TClass *cl = 0) = 0;
   virtual Version_t ReadVersion(UInt_t *start = 0, UInt_t *bcnt = 0, const TClass *cl = 0) = 0;
   virtual Version_t ReadVersionForMemberWise(const TClass *cl = 0) = 0;
   virtual UInt_t WriteVersion(const TClass *cl, Bool_t useBcnt = kFALSE) = 0;
   virtual UInt_t WriteVersionMemberWise(const TClass *cl, Bool_t useBcnt = kFALSE) = 0;

   virtual void *ReadObjectAny(const TClass* cast) = 0;
   virtual void SkipObjectAny() = 0;

   virtual void TagStreamerInfo(TVirtualStreamerInfo* info) = 0;
   virtual void IncrementLevel(TVirtualStreamerInfo* info) = 0;
   virtual void SetStreamerElementNumber(Int_t) = 0;
   virtual void DecrementLevel(TVirtualStreamerInfo*) = 0;

   virtual void ClassBegin(const TClass*, Version_t = -1) = 0;
   virtual void ClassEnd(const TClass*) = 0;
   virtual void ClassMember(const char*, const char* = 0, Int_t = -1, Int_t = -1) = 0;
   virtual TVirtualStreamerInfo *GetInfo() = 0;

   virtual TVirtualArray *PeekDataCache() const;
   virtual TVirtualArray *PopDataCache();
   virtual void PushDataCache(TVirtualArray *);

   virtual TClass *ReadClass(const TClass *cl = 0, UInt_t *objTag = 0) = 0;
   virtual void WriteClass(const TClass *cl) = 0;

   virtual TObject *ReadObject(const TClass *cl) = 0;
   virtual void WriteObject(const TObject *obj) = 0;

   virtual Int_t WriteObjectAny(const void *obj, const TClass *ptrClass) = 0;

   virtual UShort_t GetPidOffset() const = 0;
   virtual void SetPidOffset(UShort_t offset) = 0;
   virtual Int_t GetBufferDisplacement() const = 0;
   virtual void SetBufferDisplacement() = 0;
   virtual void SetBufferDisplacement(Int_t skipped) = 0;

   // basic types and arrays of basic types
   virtual void ReadFloat16 (Float_t *f, TStreamerElement *ele=0) = 0;
   virtual void WriteFloat16(Float_t *f, TStreamerElement *ele=0) = 0;
   virtual void ReadDouble32 (Double_t *d, TStreamerElement *ele=0) = 0;
   virtual void WriteDouble32(Double_t *d, TStreamerElement *ele=0) = 0;
   virtual void ReadWithFactor(Float_t *ptr, Double_t factor, Double_t minvalue) = 0;
   virtual void ReadWithNbits(Float_t *ptr, Int_t nbits) = 0;
   virtual void ReadWithFactor(Double_t *ptr, Double_t factor, Double_t minvalue) = 0;
   virtual void ReadWithNbits(Double_t *ptr, Int_t nbits) = 0;

   virtual Int_t ReadArray(Bool_t *&b) = 0;
   virtual Int_t ReadArray(Char_t *&c) = 0;
   virtual Int_t ReadArray(UChar_t *&c) = 0;
   virtual Int_t ReadArray(Short_t *&h) = 0;
   virtual Int_t ReadArray(UShort_t *&h) = 0;
   virtual Int_t ReadArray(Int_t *&i) = 0;
   virtual Int_t ReadArray(UInt_t *&i) = 0;
   virtual Int_t ReadArray(Long_t *&l) = 0;
   virtual Int_t ReadArray(ULong_t *&l) = 0;
   virtual Int_t ReadArray(Long64_t *&l) = 0;
   virtual Int_t ReadArray(ULong64_t *&l) = 0;
   virtual Int_t ReadArray(Float_t *&f) = 0;
   virtual Int_t ReadArray(Double_t *&d) = 0;
   virtual Int_t ReadArrayFloat16(Float_t *&f, TStreamerElement *ele=0) = 0;
   virtual Int_t ReadArrayDouble32(Double_t *&d, TStreamerElement *ele=0) = 0;

   virtual Int_t ReadStaticArray(Bool_t *b) = 0;
   virtual Int_t ReadStaticArray(Char_t *c) = 0;
   virtual Int_t ReadStaticArray(UChar_t *c) = 0;
   virtual Int_t ReadStaticArray(Short_t *h) = 0;
   virtual Int_t ReadStaticArray(UShort_t *h) = 0;
   virtual Int_t ReadStaticArray(Int_t *i) = 0;
   virtual Int_t ReadStaticArray(UInt_t *i) = 0;
   virtual Int_t ReadStaticArray(Long_t *l) = 0;
   virtual Int_t ReadStaticArray(ULong_t *l) = 0;
   virtual Int_t ReadStaticArray(Long64_t *l) = 0;
   virtual Int_t ReadStaticArray(ULong64_t *l) = 0;
   virtual Int_t ReadStaticArray(Float_t *f) = 0;
   virtual Int_t ReadStaticArray(Double_t *d) = 0;
   virtual Int_t ReadStaticArrayFloat16(Float_t *f, TStreamerElement *ele=0) = 0;
   virtual Int_t ReadStaticArrayDouble32(Double_t *d, TStreamerElement *ele=0) = 0;

   virtual void ReadFastArray(Bool_t *b, Int_t n) = 0;
   virtual void ReadFastArray(Char_t *c, Int_t n) = 0;
   virtual void ReadFastArrayString(Char_t *c, Int_t n) = 0;
   virtual void ReadFastArray(UChar_t *c, Int_t n) = 0;
   virtual void ReadFastArray(Short_t *h, Int_t n) = 0;
   virtual void ReadFastArray(UShort_t *h, Int_t n) = 0;
   virtual void ReadFastArray(Int_t *i, Int_t n) = 0;
   virtual void ReadFastArray(UInt_t *i, Int_t n) = 0;
   virtual void ReadFastArray(Long_t *l, Int_t n) = 0;
   virtual void ReadFastArray(ULong_t *l, Int_t n) = 0;
   virtual void ReadFastArray(Long64_t *l, Int_t n) = 0;
   virtual void ReadFastArray(ULong64_t *l, Int_t n) = 0;
   virtual void ReadFastArray(Float_t *f, Int_t n) = 0;
   virtual void ReadFastArray(Double_t *d, Int_t n) = 0;
   virtual void ReadFastArrayFloat16(Float_t *f, Int_t n, TStreamerElement *ele=0) = 0;
   virtual void ReadFastArrayDouble32(Double_t *d, Int_t n, TStreamerElement *ele=0) = 0;
   virtual void ReadFastArray(void *start , const TClass *cl, Int_t n=1, TMemberStreamer *s=0, const TClass *onFileClass=0) = 0;
   virtual void ReadFastArray(void **startp, const TClass *cl, Int_t n=1, Bool_t isPreAlloc=kFALSE, TMemberStreamer *s=0, const TClass *onFileClass=0) = 0;

   virtual void WriteArray(const Bool_t *b, Int_t n) = 0;
   virtual void WriteArray(const Char_t *c, Int_t n) = 0;
   virtual void WriteArray(const UChar_t *c, Int_t n) = 0;
   virtual void WriteArray(const Short_t *h, Int_t n) = 0;
   virtual void WriteArray(const UShort_t *h, Int_t n) = 0;
   virtual void WriteArray(const Int_t *i, Int_t n) = 0;
   virtual void WriteArray(const UInt_t *i, Int_t n) = 0;
   virtual void WriteArray(const Long_t *l, Int_t n) = 0;
   virtual void WriteArray(const ULong_t *l, Int_t n) = 0;
   virtual void WriteArray(const Long64_t *l, Int_t n) = 0;
   virtual void WriteArray(const ULong64_t *l, Int_t n) = 0;
   virtual void WriteArray(const Float_t *f, Int_t n) = 0;
   virtual void WriteArray(const Double_t *d, Int_t n) = 0;
   virtual void WriteArrayFloat16(const Float_t *f, Int_t n, TStreamerElement *ele=0) = 0;
   virtual void WriteArrayDouble32(const Double_t *d, Int_t n, TStreamerElement *ele=0) = 0;

   virtual void WriteFastArray(const Bool_t *b, Int_t n) = 0;
   virtual void WriteFastArray(const Char_t *c, Int_t n) = 0;
   virtual void WriteFastArrayString(const Char_t *c, Int_t n) = 0;
   virtual void WriteFastArray(const UChar_t *c, Int_t n) = 0;
   virtual void WriteFastArray(const Short_t *h, Int_t n) = 0;
   virtual void WriteFastArray(const UShort_t *h, Int_t n) = 0;
   virtual void WriteFastArray(const Int_t *i, Int_t n) = 0;
   virtual void WriteFastArray(const UInt_t *i, Int_t n) = 0;
   virtual void WriteFastArray(const Long_t *l, Int_t n) = 0;
   virtual void WriteFastArray(const ULong_t *l, Int_t n) = 0;
   virtual void WriteFastArray(const Long64_t *l, Int_t n) = 0;
   virtual void WriteFastArray(const ULong64_t *l, Int_t n) = 0;
   virtual void WriteFastArray(const Float_t *f, Int_t n) = 0;
   virtual void WriteFastArray(const Double_t *d, Int_t n) = 0;
   virtual void WriteFastArrayFloat16(const Float_t *f, Int_t n, TStreamerElement *ele=0) = 0;
   virtual void WriteFastArrayDouble32(const Double_t *d, Int_t n, TStreamerElement *ele=0) = 0;
   virtual void WriteFastArray(void *start, const TClass *cl, Int_t n=1, TMemberStreamer *s=0) = 0;
   virtual Int_t WriteFastArray(void **startp, const TClass *cl, Int_t n=1, Bool_t isPreAlloc=kFALSE, TMemberStreamer *s=0) = 0;

   virtual void StreamObject(void *obj, const type_info &typeinfo, const TClass* onFileClass = 0 ) = 0;
   virtual void StreamObject(void *obj, const char *className, const TClass* onFileClass = 0 ) = 0;
   virtual void StreamObject(void *obj, const TClass *cl, const TClass* onFileClass = 0 ) = 0;
   virtual void StreamObject(TObject *obj) = 0;

   virtual void ReadBool(Bool_t &b) = 0;
   virtual void ReadChar(Char_t &c) = 0;
   virtual void ReadUChar(UChar_t &c) = 0;
   virtual void ReadShort(Short_t &s) = 0;
   virtual void ReadUShort(UShort_t &s) = 0;
   virtual void ReadInt(Int_t &i) = 0;
   virtual void ReadUInt(UInt_t &i) = 0;
   virtual void ReadLong(Long_t &l) = 0;
   virtual void ReadULong(ULong_t &l) = 0;
   virtual void ReadLong64(Long64_t &l) = 0;
   virtual void ReadULong64(ULong64_t &l) = 0;
   virtual void ReadFloat(Float_t &f) = 0;
   virtual void ReadDouble(Double_t &d) = 0;
   virtual void ReadCharP(Char_t *c) = 0;
   virtual void ReadTString(TString &s) = 0;

   virtual void WriteBool(Bool_t b) = 0;
   virtual void WriteChar(Char_t c) = 0;
   virtual void WriteUChar(UChar_t c) = 0;
   virtual void WriteShort(Short_t s) = 0;
   virtual void WriteUShort(UShort_t s) = 0;
   virtual void WriteInt(Int_t i) = 0;
   virtual void WriteUInt(UInt_t i) = 0;
   virtual void WriteLong(Long_t l) = 0;
   virtual void WriteULong(ULong_t l) = 0;
   virtual void WriteLong64(Long64_t l) = 0;
   virtual void WriteULong64(ULong64_t l) = 0;
   virtual void WriteFloat(Float_t f) = 0;
   virtual void WriteDouble(Double_t d) = 0;
   virtual void WriteCharP(const Char_t *c) = 0;
   virtual void WriteTString(const TString &s) = 0;

   // Special basic ROOT objects and collections
   virtual TProcessID *GetLastProcessID(TRefTable *reftable) const = 0;
   virtual UInt_t GetTRefExecId() = 0;
   virtual TProcessID *ReadProcessID(UShort_t pidf) = 0;
   virtual UShort_t WriteProcessID(TProcessID *pid) = 0;

   // Utilities for TStreamerInfo
   virtual void ForceWriteInfo(TVirtualStreamerInfo *info, Bool_t force) = 0;
   virtual void ForceWriteInfoClones(TClonesArray *a) = 0;
   virtual Int_t ReadClones (TClonesArray *a, Int_t nobjects, Version_t objvers) = 0;
   virtual Int_t WriteClones(TClonesArray *a, Int_t nobjects) = 0;

   // Utilities for TClass
   virtual Int_t ReadClassEmulated(const TClass *cl, void *object, const TClass *onfile_class = 0) = 0;
   virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class = 0) = 0;
   virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, Int_t version, UInt_t start, UInt_t count, const TClass *onfile_class = 0) = 0;
   virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer) = 0;

   // Utilites to streamer using sequences.
   virtual Int_t ApplySequence(const TStreamerInfoActions::TActionSequence &sequence, void *object) = 0;
   virtual Int_t ApplySequenceVecPtr(const TStreamerInfoActions::TActionSequence &sequence, void *start_collection, void *end_collection) = 0;
   virtual Int_t ApplySequence(const TStreamerInfoActions::TActionSequence &sequence, void *start_collection, void *end_collection) = 0;

   static TClass *GetClass(const type_info &typeinfo);
   static TClass *GetClass(const char *className);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TBuffer::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TBuffer::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBuffer.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 318; } //Buffer base class used for serializing objects
};

//---------------------- TBuffer default external operators --------------------

inline TBuffer &operator>>(TBuffer &buf, Bool_t &b) { buf.ReadBool(b); return buf; }
inline TBuffer &operator>>(TBuffer &buf, Char_t &c) { buf.ReadChar(c); return buf; }
inline TBuffer &operator>>(TBuffer &buf, UChar_t &c) { buf.ReadUChar(c); return buf; }
inline TBuffer &operator>>(TBuffer &buf, Short_t &s) { buf.ReadShort(s); return buf; }
inline TBuffer &operator>>(TBuffer &buf, UShort_t &s) { buf.ReadUShort(s); return buf; }
inline TBuffer &operator>>(TBuffer &buf, Int_t &i) { buf.ReadInt(i); return buf; }
inline TBuffer &operator>>(TBuffer &buf, UInt_t &i) { buf.ReadUInt(i); return buf; }
inline TBuffer &operator>>(TBuffer &buf, Long_t &l) { buf.ReadLong(l); return buf; }
inline TBuffer &operator>>(TBuffer &buf, ULong_t &l) { buf.ReadULong(l); return buf; }
inline TBuffer &operator>>(TBuffer &buf, Long64_t &l) { buf.ReadLong64(l); return buf; }
inline TBuffer &operator>>(TBuffer &buf, ULong64_t &l){ buf.ReadULong64(l);return buf; }
inline TBuffer &operator>>(TBuffer &buf, Float_t &f) { buf.ReadFloat(f); return buf; }
inline TBuffer &operator>>(TBuffer &buf, Double_t &d) { buf.ReadDouble(d); return buf; }
inline TBuffer &operator>>(TBuffer &buf, Char_t *c) { buf.ReadCharP(c); return buf; }
inline TBuffer &operator>>(TBuffer &buf, TString &s) { buf.ReadTString(s);return buf; }

inline TBuffer &operator<<(TBuffer &buf, Bool_t b) { buf.WriteBool(b); return buf; }
inline TBuffer &operator<<(TBuffer &buf, Char_t c) { buf.WriteChar(c); return buf; }
inline TBuffer &operator<<(TBuffer &buf, UChar_t c) { buf.WriteUChar(c); return buf; }
inline TBuffer &operator<<(TBuffer &buf, Short_t s) { buf.WriteShort(s); return buf; }
inline TBuffer &operator<<(TBuffer &buf, UShort_t s) { buf.WriteUShort(s); return buf; }
inline TBuffer &operator<<(TBuffer &buf, Int_t i) { buf.WriteInt(i); return buf; }
inline TBuffer &operator<<(TBuffer &buf, UInt_t i) { buf.WriteUInt(i); return buf; }
inline TBuffer &operator<<(TBuffer &buf, Long_t l) { buf.WriteLong(l); return buf; }
inline TBuffer &operator<<(TBuffer &buf, ULong_t l) { buf.WriteULong(l); return buf; }
inline TBuffer &operator<<(TBuffer &buf, Long64_t l) { buf.WriteLong64(l); return buf; }
inline TBuffer &operator<<(TBuffer &buf, ULong64_t l){ buf.WriteULong64(l);return buf; }
inline TBuffer &operator<<(TBuffer &buf, Float_t f) { buf.WriteFloat(f); return buf; }
inline TBuffer &operator<<(TBuffer &buf, Double_t d) { buf.WriteDouble(d); return buf; }
inline TBuffer &operator<<(TBuffer &buf, const Char_t *c) { buf.WriteCharP(c); return buf; }
inline TBuffer &operator<<(TBuffer &buf, const TString &s) { buf.WriteTString(s);return buf; }
# 385 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBuffer.h"
template <class Tmpl> TBuffer &operator>>(TBuffer &buf, Tmpl *&obj);
template <class Tmpl> TBuffer &operator<<(TBuffer &buf, Tmpl *&obj);






inline TBuffer &operator<<(TBuffer &buf, const TObject *obj)
   { buf.WriteObjectAny(obj, TObject::Class()); return buf; }
# 231 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 2
# 2 "/tmp/rootcint_hxzv6S.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMemberInspector.h" 1
// @(#)root/base:$Id: TMemberInspector.h 43276 2012-03-07 17:13:42Z pcanal $
// Author: Fons Rademakers   15/07/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMemberInspector                                                     //
//                                                                      //
// Abstract base class for accessing the datamembers of a class.        //
// Classes derived from this class can be given as argument to the      //
// ShowMembers() methods of ROOT classes. This feature facilitates      //
// the writing of class browsers and inspectors.                        //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 1
/* @(#)root/base:$Id: Rtypes.h 43708 2012-04-12 10:19:00Z axel $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 27 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMemberInspector.h" 2

class TObject;
class TClass;

class TMemberInspector {
private:
   class TParentBuf;
   TParentBuf* fParent; // current inspection "path"

   TMemberInspector(const TMemberInspector&); // Not implemented.
   TMemberInspector &operator=(const TMemberInspector&); // Not implemented.

public:
   TMemberInspector();
   virtual ~TMemberInspector();

   virtual void Inspect(TClass *cl, const char *parent, const char *name, const void *addr) = 0;

   const char* GetParent() const;
   Ssiz_t GetParentLen() const;
   void AddToParent(const char* name);
   void RemoveFromParent(Ssiz_t startingAt);

   template <class T>
   void InspectMember(T& obj, const char* name) {
      Ssiz_t len = GetParentLen();
      AddToParent(name);
      obj.ShowMembers(*this);
      RemoveFromParent(len);
   }

   void InspectMember(TObject& obj, const char* name);
   void InspectMember(const char* topclassname, void* pobj, const char* name,
                      Bool_t transient);
   void InspectMember(TClass* cl, void* pobj, const char* name);

   void GenericShowMembers(const char *topClassName, void *obj,
                           Bool_t transientMember);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TMemberInspector::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TMemberInspector::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMemberInspector.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 66; } //ABC for inspecting class data members
};
# 3 "/tmp/rootcint_hxzv6S.h" 2
# 1 "./include/MDCSimulator.hh" 1


// Telemetry Output Simulation using MDCSimulator
// ... from Trig_rate.cc (by KS)
// ... Modification log:
//     130625 YA: Calib_st added => using libdbint.so by HM
//     - calibration data made by writecalib_130626.py
//     130626 YA: MDC_Simulator => MDCSimulator
//     130626 YA: Event_st added
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/time.h" 1


typedef unsigned long clock_t;
typedef long time_t;

#pragma setstdstruct
# 11 "./include/MDCSimulator.hh" 2
# 1 "/usr/include/sys/time.h" 1 3 4
/* Copyright (C) 1991-1994,1996-2003,2005,2006,2009
	Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */




# 1 "/usr/include/features.h" 1 3 4
/* Copyright (C) 1991-1993,1995-2007,2009,2010 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */
# 24 "/usr/include/sys/time.h" 2 3 4

# 1 "/usr/include/bits/types.h" 1 3 4
/* bits/types.h -- definitions of __*_t types underlying *_t types.
   Copyright (C) 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

/*
 * Never include this file directly; use <sys/types.h> instead.
 */




# 1 "/usr/include/features.h" 1 3 4
/* Copyright (C) 1991-1993,1995-2007,2009,2010 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */
# 28 "/usr/include/bits/types.h" 2 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
/* Determine the wordsize from the preprocessor defines.  */
# 29 "/usr/include/bits/types.h" 2 3 4

/* Convenience types.  */
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;

/* Fixed-size types, underlying types depend on word size and compiler.  */
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;

typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;





/* quad_t is also 64 bits.  */

typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
# 70 "/usr/include/bits/types.h" 3 4
/* The machine-dependent file <bits/typesizes.h> defines __*_T_TYPE
   macros for each of the OS types we define below.  The definitions
   of those macros must use the following macros for underlying types.
   We define __S<SIZE>_TYPE and __U<SIZE>_TYPE for the signed and unsigned
   variants of each of the following integer types on this machine.

	16		-- "natural" 16-bit type (always short)
	32		-- "natural" 32-bit type (always int)
	64		-- "natural" 64-bit type (long or long long)
	LONG32		-- 32-bit type, traditionally long
	QUAD		-- 64-bit type, always long long
	WORD		-- natural type of __WORDSIZE bits (int or long)
	LONGWORD	-- type of __WORDSIZE bits, traditionally long

   We distinguish WORD/LONGWORD, 32/LONG32, and 64/QUAD so that the
   conventional uses of `long' or `long long' type modifiers match the
   types we define, even when a less-adorned type would be the same size.
   This matters for (somewhat) portably writing printf/scanf formats for
   these types, where using the appropriate l or ll format modifiers can
   make the typedefs and the formats match up across all GNU platforms.  If
   we used `long' when it's 64 bits where `long long' is expected, then the
   compiler would warn about the formats not matching the argument types,
   and the programmer changing them to shut up the compiler would break the
   program's portability.

   Here we assume what is presently the case in all the GCC configurations
   we support: long long is always 64 bits, long is always word/address size,
   and int is always 32 bits.  */
# 126 "/usr/include/bits/types.h" 3 4
/* No need to mark the typedef with __extension__.   */




# 1 "/usr/include/bits/typesizes.h" 1 3 4
/* bits/typesizes.h -- underlying types for *_t.  Generic version.
   Copyright (C) 2002, 2003 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */
# 27 "/usr/include/bits/typesizes.h" 3 4
/* See <bits/types.h> for the meaning of these macros.  This file exists so
   that <bits/types.h> need not vary across different GNU platforms.  */
# 62 "/usr/include/bits/typesizes.h" 3 4
/* Number of descriptors that can fit in an `fd_set'.  */
# 132 "/usr/include/bits/types.h" 2 3 4


typedef unsigned long int __dev_t; /* Type of device numbers.  */
typedef unsigned int __uid_t; /* Type of user identifications.  */
typedef unsigned int __gid_t; /* Type of group identifications.  */
typedef unsigned long int __ino_t; /* Type of file serial numbers.  */
typedef unsigned long int __ino64_t; /* Type of file serial numbers (LFS).*/
typedef unsigned int __mode_t; /* Type of file attribute bitmasks.  */
typedef unsigned long int __nlink_t; /* Type of file link counts.  */
typedef long int __off_t; /* Type of file sizes and offsets.  */
typedef long int __off64_t; /* Type of file sizes and offsets (LFS).  */
typedef int __pid_t; /* Type of process identifications.  */
typedef struct { int __val[2]; } __fsid_t; /* Type of file system IDs.  */
typedef long int __clock_t; /* Type of CPU usage counts.  */
typedef unsigned long int __rlim_t; /* Type for resource measurement.  */
typedef unsigned long int __rlim64_t; /* Type for resource measurement (LFS).  */
typedef unsigned int __id_t; /* General type for IDs.  */
typedef long int __time_t; /* Seconds since the Epoch.  */
typedef unsigned int __useconds_t; /* Count of microseconds.  */
typedef long int __suseconds_t; /* Signed count of microseconds.  */

typedef int __daddr_t; /* The type of a disk address.  */
typedef long int __swblk_t; /* Type of a swap block maybe?  */
typedef int __key_t; /* Type of an IPC key.  */

/* Clock ID used in clock and timer functions.  */
typedef int __clockid_t;

/* Timer ID returned by `timer_create'.  */
typedef void * __timer_t;

/* Type to represent block size.  */
typedef long int __blksize_t;

/* Types from the Large File Support interface.  */

/* Type to count number of disk blocks.  */
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;

/* Type to count file system blocks.  */
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;

/* Type to count file system nodes.  */
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;

typedef long int __ssize_t; /* Type of a byte count, or error.  */

/* These few don't really vary by system, they always correspond
   to one of the other defined types.  */
typedef __off64_t __loff_t; /* Type of file sizes and offsets (LFS).  */
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;

/* Duplicates info from stdint.h but this is used in unistd.h.  */
typedef long int __intptr_t;

/* Duplicate info from sys/socket.h.  */
typedef unsigned int __socklen_t;
# 26 "/usr/include/sys/time.h" 2 3 4



# 1 "/usr/include/bits/time.h" 1 3 4
/* System-dependent timing definitions.  Generic version.
   Copyright (C) 1996,1997,1999-2002,2003,2010 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

/*
 * Never include this file directly; use <time.h> instead.
 */
# 71 "/usr/include/bits/time.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
/* bits/types.h -- definitions of __*_t types underlying *_t types.
   Copyright (C) 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

/*
 * Never include this file directly; use <sys/types.h> instead.
 */
# 72 "/usr/include/bits/time.h" 2 3 4

/* A time value that is accurate to the nearest
   microsecond but also has a range of years.  */
struct timeval
  {
    __time_t tv_sec; /* Seconds.  */
    __suseconds_t tv_usec; /* Microseconds.  */
  };
# 30 "/usr/include/sys/time.h" 2 3 4

# 1 "/usr/include/sys/select.h" 1 3 4
/* `fd_set' type and related macros, and `select'/`pselect' declarations.
   Copyright (C) 1996-2003, 2009 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

/*	POSIX 1003.1g: 6.2 Select from File Descriptor Sets <sys/select.h>  */




# 1 "/usr/include/features.h" 1 3 4
/* Copyright (C) 1991-1993,1995-2007,2009,2010 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */
# 26 "/usr/include/sys/select.h" 2 3 4

/* Get definition of needed basic types.  */
# 1 "/usr/include/bits/types.h" 1 3 4
/* bits/types.h -- definitions of __*_t types underlying *_t types.
   Copyright (C) 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

/*
 * Never include this file directly; use <sys/types.h> instead.
 */
# 29 "/usr/include/sys/select.h" 2 3 4

/* Get __FD_* definitions.  */
# 1 "/usr/include/bits/select.h" 1 3 4
/* Copyright (C) 1997,1998,1999,2001,2008,2009 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */





# 1 "/usr/include/bits/wordsize.h" 1 3 4
/* Determine the wordsize from the preprocessor defines.  */
# 24 "/usr/include/bits/select.h" 2 3 4
# 32 "/usr/include/sys/select.h" 2 3 4

/* Get __sigset_t.  */
# 1 "/usr/include/bits/sigset.h" 1 3 4
/* __sig_atomic_t, __sigset_t, and related definitions.  Linux version.
   Copyright (C) 1991, 1992, 1994, 1996, 1997, 2007
   Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */




typedef int __sig_atomic_t;

/* A `sigset_t' has a bit for each signal.  */


typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
  } __sigset_t;




/* We only want to define these functions if <signal.h> was actually
   included; otherwise we were included just to define the types.  Since we
   are namespace-clean, it wouldn't hurt to define extra macros.  But
   trouble can be caused by functions being defined (e.g., any global
   register vars declared later will cause compilation errors).  */
# 35 "/usr/include/sys/select.h" 2 3 4



typedef __sigset_t sigset_t;


/* Get definition of timer specification structures.  */




# 1 "/usr/include/bits/time.h" 1 3 4
/* System-dependent timing definitions.  Generic version.
   Copyright (C) 1996,1997,1999-2002,2003,2010 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

/*
 * Never include this file directly; use <time.h> instead.
 */
# 47 "/usr/include/sys/select.h" 2 3 4


typedef __suseconds_t suseconds_t;




/* The fd_set member is required to be an array of longs.  */
typedef long int __fd_mask;

/* Some versions of <linux/posix_types.h> define these macros.  */



/* It's easier to assume 8-bit bytes than to get CHAR_BIT.  */




/* fd_set for select and pselect.  */
typedef struct
  {
    /* XPG4.2 requires this member name.  Otherwise avoid the name
       from the global namespace.  */

    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];





  } fd_set;

/* Maximum number of file descriptors in `fd_set'.  */



/* Sometimes the fd_set member is assumed to have this type.  */
typedef __fd_mask fd_mask;

/* Number of bits per word of `fd_set' (some code assumes this is 32).  */




/* Access macros for `fd_set'.  */






extern "C" {

/* Check the first NFDS descriptors each in READFDS (if not NULL) for read
   readiness, in WRITEFDS (if not NULL) for write readiness, and in EXCEPTFDS
   (if not NULL) for exceptional conditions.  If TIMEOUT is not NULL, time out
   after waiting the interval specified therein.  Returns the number of ready
   descriptors, or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern int select (int __nfds, fd_set *__restrict __readfds,
     fd_set *__restrict __writefds,
     fd_set *__restrict __exceptfds,
     struct timeval *__restrict __timeout);


/* Same as above only that the TIMEOUT value is given with higher
   resolution and a sigmask which is been set temporarily.  This version
   should be used.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern int pselect (int __nfds, fd_set *__restrict __readfds,
      fd_set *__restrict __writefds,
      fd_set *__restrict __exceptfds,
      const struct timespec *__restrict __timeout,
      const __sigset_t *__restrict __sigmask);


}
# 32 "/usr/include/sys/time.h" 2 3 4







extern "C" {


/* Macros for converting between `struct timeval' and `struct timespec'.  */
# 55 "/usr/include/sys/time.h" 3 4
/* Structure crudely representing a timezone.
   This is obsolete and should never be used.  */
struct timezone
  {
    int tz_minuteswest; /* Minutes west of GMT.  */
    int tz_dsttime; /* Nonzero if DST is ever in effect.  */
  };

typedef struct timezone *__restrict __timezone_ptr_t;




/* Get the current time of day and timezone information,
   putting it into *TV and *TZ.  If TZ is NULL, *TZ is not filled.
   Returns 0 on success, -1 on errors.
   NOTE: This form of timezone information is obsolete.
   Use the functions and variables declared in <time.h> instead.  */
extern int gettimeofday (struct timeval *__restrict __tv,
    __timezone_ptr_t __tz) throw () ;


/* Set the current time of day and timezone information.
   This call is restricted to the super-user.  */
extern int settimeofday (__const struct timeval *__tv,
    __const struct timezone *__tz)
     throw () ;

/* Adjust the current time of day by the amount in DELTA.
   If OLDDELTA is not NULL, it is filled in with the amount
   of time adjustment remaining to be done from the last `adjtime' call.
   This call is restricted to the super-user.  */
extern int adjtime (__const struct timeval *__delta,
      struct timeval *__olddelta) throw ();



/* Values for the first argument to `getitimer' and `setitimer'.  */
enum __itimer_which
  {
    /* Timers run in real time.  */
    ITIMER_REAL = 0,

    /* Timers run only when the process is executing.  */
    ITIMER_VIRTUAL = 1,

    /* Timers run when the process is executing and when
       the system is executing on behalf of the process.  */
    ITIMER_PROF = 2

  };

/* Type of the second argument to `getitimer' and
   the second and third arguments `setitimer'.  */
struct itimerval
  {
    /* Value to put into `it_value' when the timer expires.  */
    struct timeval it_interval;
    /* Time to the next timer expiration.  */
    struct timeval it_value;
  };






typedef int __itimer_which_t;


/* Set *VALUE to the current setting of timer WHICH.
   Return 0 on success, -1 on errors.  */
extern int getitimer (__itimer_which_t __which,
        struct itimerval *__value) throw ();

/* Set the timer WHICH to *NEW.  If OLD is not NULL,
   set *OLD to the old value of timer WHICH.
   Returns 0 on success, -1 on errors.  */
extern int setitimer (__itimer_which_t __which,
        __const struct itimerval *__restrict __new,
        struct itimerval *__restrict __old) throw ();

/* Change the access time of FILE to TVP[0] and the modification time of
   FILE to TVP[1].  If TVP is a null pointer, use the current time instead.
   Returns 0 on success, -1 on errors.  */
extern int utimes (__const char *__file, __const struct timeval __tvp[2])
     throw () ;


/* Same as `utimes', but does not follow symbolic links.  */
extern int lutimes (__const char *__file, __const struct timeval __tvp[2])
     throw () ;

/* Same as `utimes', but takes an open file descriptor instead of a name.  */
extern int futimes (int __fd, __const struct timeval __tvp[2]) throw ();



/* Change the access time of FILE relative to FD to TVP[0] and the
   modification time of FILE to TVP[1].  If TVP is a null pointer, use
   the current time instead.  Returns 0 on success, -1 on errors.  */
extern int futimesat (int __fd, __const char *__file,
        __const struct timeval __tvp[2]) throw ();




/* Convenience macros for operations on timevals.
   NOTE: `timercmp' does not work for >= or <=.  */
# 191 "/usr/include/sys/time.h" 3 4
}
# 12 "./include/MDCSimulator.hh" 2
# 1 "/usr/include/popt.h" 1 3 4
/** \file popt/popt.h
 * \ingroup popt
 */

/* (C) 1998-2000 Red Hat, Inc. -- Licensing details are in the COPYING
   file accompanying popt source distributions, available from 
   ftp://ftp.rpm.org/pub/rpm/dist. */
# 16 "/usr/include/popt.h" 3 4
/** \ingroup popt
 * \name Arg type identifiers
 */
/*@{*/
# 40 "/usr/include/popt.h" 3 4
/*@}*/

/** \ingroup popt
 * \name Arg modifiers
 */
/*@{*/
# 61 "/usr/include/popt.h" 3 4
     /*!< set arg bit(s) */

     /*!< clear arg bit(s) */




/*@}*/

/** \ingroup popt
 * \name Callback modifiers
 */
/*@{*/






/*@}*/

/** \ingroup popt
 * \name Error return values
 */
/*@{*/
# 96 "/usr/include/popt.h" 3 4
/*@}*/

/** \ingroup popt
 * \name poptBadOption() flags
 */
/*@{*/

/*@}*/

/** \ingroup popt
 * \name poptGetContext() flags
 */
/*@{*/




/*@}*/

/** \ingroup popt
 */
struct poptOption {
/*@observer@*/ /*@null@*/
    const char * longName; /*!< may be NULL */
    char shortName; /*!< may be NUL */
    unsigned int argInfo;
/*@shared@*/ /*@null@*/
    void * arg; /*!< depends on argInfo */
    int val; /*!< 0 means don't return, just update flag */
/*@observer@*/ /*@null@*/
    const char * descrip; /*!< description for autohelp -- may be NULL */
/*@observer@*/ /*@null@*/
    const char * argDescrip; /*!< argument description for autohelp */
};

/** \ingroup popt
 * A popt alias argument for poptAddAlias().
 */
struct poptAlias {
/*@owned@*/ /*@null@*/
    const char * longName; /*!< may be NULL */
    char shortName; /*!< may be NUL */
    int argc;
/*@owned@*/
    const char ** argv; /*!< must be free()able */
};

/** \ingroup popt
 * A popt alias or exec argument for poptAddItem().
 */
/*@-exporttype@*/
typedef struct poptItem_s {
    struct poptOption option; /*!< alias/exec name(s) and description. */
    int argc; /*!< (alias) no. of args. */
/*@owned@*/
    const char ** argv; /*!< (alias) args, must be free()able. */
} * poptItem;
/*@=exporttype@*/

/** \ingroup popt
 * \name Auto-generated help/usage
 */
/*@{*/

/**
 * Empty table marker to enable displaying popt alias/exec options.
 */
/*@-exportvar@*/
/*@unchecked@*/ /*@observer@*/
extern struct poptOption poptAliasOptions[];
/*@=exportvar@*/



/**
 * Auto help table options.
 */
/*@-exportvar@*/
/*@unchecked@*/ /*@observer@*/
extern struct poptOption poptHelpOptions[];
/*@=exportvar@*/

/*@-exportvar@*/
/*@unchecked@*/ /*@observer@*/
extern struct poptOption * poptHelpOptionsI18N;
/*@=exportvar@*/





/*@}*/

/** \ingroup popt
 */
/*@-exporttype@*/
typedef /*@abstract@*/ struct poptContext_s * poptContext;
/*@=exporttype@*/

/** \ingroup popt
 */






/** \ingroup popt
 */
/*@-exportconst@*/
enum poptCallbackReason {
    POPT_CALLBACK_REASON_PRE = 0,
    POPT_CALLBACK_REASON_POST = 1,
    POPT_CALLBACK_REASON_OPTION = 2
};
/*@=exportconst@*/


extern "C" {

/*@-type@*/

/** \ingroup popt
 * Table callback prototype.
 * @param con		context
 * @param reason	reason for callback
 * @param opt		option that triggered callback
 * @param arg		@todo Document.
 * @param data		@todo Document.
 */
typedef void (*poptCallbackType) (poptContext con,
  enum poptCallbackReason reason,
  /*@null@*/ const struct poptOption * opt,
  /*@null@*/ const char * arg,
  /*@null@*/ const void * data)
 /*@globals internalState @*/
 /*@modifies internalState @*/;

/** \ingroup popt
 * Initialize popt context.
 * @param name		context name (usually argv[0] program name)
 * @param argc		no. of arguments
 * @param argv		argument array
 * @param options	address of popt option table
 * @param flags		or'd POPT_CONTEXT_* bits
 * @return		initialized popt context
 */
/*@only@*/ /*@null@*/
poptContext poptGetContext(
  /*@dependent@*/ /*@keep@*/ const char * name,
  int argc, /*@dependent@*/ /*@keep@*/ const char ** argv,
  /*@dependent@*/ /*@keep@*/ const struct poptOption * options,
  unsigned int flags)
 /*@*/;

/** \ingroup popt
 * Reinitialize popt context.
 * @param con		context
 */
/*@unused@*/
void poptResetContext(/*@null@*/poptContext con)
 /*@modifies con @*/;

/** \ingroup popt
 * Return value of next option found.
 * @param con		context
 * @return		next option val, -1 on last item, POPT_ERROR_* on error
 */
int poptGetNextOpt(/*@null@*/poptContext con)
 /*@globals fileSystem, internalState @*/
 /*@modifies con, fileSystem, internalState @*/;

/** \ingroup popt
 * Return next option argument (if any).
 * @param con		context
 * @return		option argument, NULL if no argument is available
 */
/*@observer@*/ /*@null@*/ /*@unused@*/
char * poptGetOptArg(/*@null@*/poptContext con)
 /*@modifies con @*/;

/** \ingroup popt
 * Return next argument.
 * @param con		context
 * @return		next argument, NULL if no argument is available
 */
/*@observer@*/ /*@null@*/ /*@unused@*/
const char * poptGetArg(/*@null@*/poptContext con)
 /*@modifies con @*/;

/** \ingroup popt
 * Peek at current argument.
 * @param con		context
 * @return		current argument, NULL if no argument is available
 */
/*@observer@*/ /*@null@*/ /*@unused@*/
const char * poptPeekArg(/*@null@*/poptContext con)
 /*@*/;

/** \ingroup popt
 * Return remaining arguments.
 * @param con		context
 * @return		argument array, NULL terminated
 */
/*@observer@*/ /*@null@*/
const char ** poptGetArgs(/*@null@*/poptContext con)
 /*@modifies con @*/;

/** \ingroup popt
 * Return the option which caused the most recent error.
 * @param con		context
 * @param flags
 * @return		offending option
 */
/*@observer@*/
const char * poptBadOption(/*@null@*/poptContext con, unsigned int flags)
 /*@*/;

/** \ingroup popt
 * Destroy context.
 * @param con		context
 * @return		NULL always
 */
/*@null@*/
poptContext poptFreeContext( /*@only@*/ /*@null@*/ poptContext con)
 /*@modifies con @*/;

/** \ingroup popt
 * Add arguments to context.
 * @param con		context
 * @param argv		argument array, NULL terminated
 * @return		0 on success, POPT_ERROR_OPTSTOODEEP on failure
 */
/*@unused@*/
int poptStuffArgs(poptContext con, /*@keep@*/ const char ** argv)
 /*@modifies con @*/;

/** \ingroup popt
 * Add alias to context.
 * @todo Pass alias by reference, not value.
 * @deprecated Use poptAddItem instead.
 * @param con		context
 * @param alias		alias to add
 * @param flags		(unused)
 * @return		0 on success
 */
/*@unused@*/
int poptAddAlias(poptContext con, struct poptAlias alias, int flags)
 /*@modifies con @*/;

/** \ingroup popt
 * Add alias/exec item to context.
 * @param con		context
 * @param newItem	alias/exec item to add
 * @param flags		0 for alias, 1 for exec
 * @return		0 on success
 */
int poptAddItem(poptContext con, poptItem newItem, int flags)
 /*@modifies con @*/;

/** \ingroup popt
 * Read configuration file.
 * @param con		context
 * @param fn		file name to read
 * @return		0 on success, POPT_ERROR_ERRNO on failure
 */
int poptReadConfigFile(poptContext con, const char * fn)
 /*@globals errno, fileSystem, internalState @*/
 /*@modifies con->execs, con->numExecs,
		errno, fileSystem, internalState @*/;

/** \ingroup popt
 * Read default configuration from /etc/popt and $HOME/.popt.
 * @param con		context
 * @param useEnv	(unused)
 * @return		0 on success, POPT_ERROR_ERRNO on failure
 */
/*@unused@*/
int poptReadDefaultConfig(poptContext con, /*@unused@*/ int useEnv)
 /*@globals fileSystem, internalState @*/
 /*@modifies con->execs, con->numExecs,
		fileSystem, internalState @*/;

/** \ingroup popt
 * Duplicate an argument array.
 * @note: The argument array is malloc'd as a single area, so only argv must
 * be free'd.
 *
 * @param argc		no. of arguments
 * @param argv		argument array
 * @retval argcPtr	address of returned no. of arguments
 * @retval argvPtr	address of returned argument array
 * @return		0 on success, POPT_ERROR_NOARG on failure
 */
int poptDupArgv(int argc, /*@null@*/ const char **argv,
  /*@null@*/ /*@out@*/ int * argcPtr,
  /*@null@*/ /*@out@*/ const char *** argvPtr)
 /*@modifies *argcPtr, *argvPtr @*/;

/** \ingroup popt
 * Parse a string into an argument array.
 * The parse allows ', ", and \ quoting, but ' is treated the same as " and
 * both may include \ quotes.
 * @note: The argument array is malloc'd as a single area, so only argv must
 * be free'd.
 *
 * @param s		string to parse
 * @retval argcPtr	address of returned no. of arguments
 * @retval argvPtr	address of returned argument array
 */
int poptParseArgvString(const char * s,
  /*@out@*/ int * argcPtr, /*@out@*/ const char *** argvPtr)
 /*@modifies *argcPtr, *argvPtr @*/;

/** \ingroup popt
 * Parses an input configuration file and returns an string that is a 
 * command line.  For use with popt.  You must free the return value when done.
 *
 * Given the file:
\verbatim
# this line is ignored
    #   this one too
aaa
  bbb
    ccc   
bla=bla

this_is   =   fdsafdas
     bad_line=        
  reall bad line  
  reall bad line  = again
5555=   55555   
  test = with lots of spaces
\endverbatim
*
* The result is:
\verbatim
--aaa --bbb --ccc --bla="bla" --this_is="fdsafdas" --5555="55555" --test="with lots of spaces"
\endverbatim
*
* Passing this to poptParseArgvString() yields an argv of:
\verbatim
'--aaa'
'--bbb' 
'--ccc' 
'--bla=bla' 
'--this_is=fdsafdas' 
'--5555=55555' 
'--test=with lots of spaces' 
\endverbatim
 *
 * @bug NULL is returned if file line is too long.
 * @bug Silently ignores invalid lines.
 *
 * @param fp		file handle to read
 * @param *argstrp	return string of options (malloc'd)
 * @param flags		unused
 * @return		0 on success
 * @see			poptParseArgvString
 */
/*@-fcnuse@*/
int poptConfigFileToString(FILE *fp, /*@out@*/ char ** argstrp, int flags)
 /*@globals fileSystem @*/
 /*@modifies *fp, *argstrp, fileSystem @*/;
/*@=fcnuse@*/

/** \ingroup popt
 * Return formatted error string for popt failure.
 * @param error		popt error
 * @return		error string
 */
/*@observer@*/
const char * poptStrerror(const int error)
 /*@*/;

/** \ingroup popt
 * Limit search for executables.
 * @param con		context
 * @param path		single path to search for executables
 * @param allowAbsolute	absolute paths only?
 */
/*@unused@*/
void poptSetExecPath(poptContext con, const char * path, int allowAbsolute)
 /*@modifies con @*/;

/** \ingroup popt
 * Print detailed description of options.
 * @param con		context
 * @param fp		ouput file handle
 * @param flags		(unused)
 */
void poptPrintHelp(poptContext con, FILE * fp, /*@unused@*/ int flags)
 /*@globals fileSystem @*/
 /*@modifies fp, fileSystem @*/;

/** \ingroup popt
 * Print terse description of options.
 * @param con		context
 * @param fp		ouput file handle
 * @param flags		(unused)
 */
void poptPrintUsage(poptContext con, FILE * fp, /*@unused@*/ int flags)
 /*@globals fileSystem @*/
 /*@modifies fp, fileSystem @*/;

/** \ingroup popt
 * Provide text to replace default "[OPTION...]" in help/usage output.
 * @param con		context
 * @param text		replacement text
 */
/*@-fcnuse@*/
void poptSetOtherOptionHelp(poptContext con, const char * text)
 /*@modifies con @*/;
/*@=fcnuse@*/

/** \ingroup popt
 * Return argv[0] from context.
 * @param con		context
 * @return		argv[0]
 */
/*@-fcnuse@*/
/*@observer@*/
const char * poptGetInvocationName(poptContext con)
 /*@*/;
/*@=fcnuse@*/

/** \ingroup popt
 * Shuffle argv pointers to remove stripped args, returns new argc.
 * @param con		context
 * @param argc		no. of args
 * @param argv		arg vector
 * @return		new argc
 */
/*@-fcnuse@*/
int poptStrippedArgv(poptContext con, int argc, char ** argv)
 /*@modifies *argv @*/;
/*@=fcnuse@*/

/**
 * Save a long, performing logical operation with value.
 * @warning Alignment check may be too strict on certain platorms.
 * @param arg		integer pointer, aligned on int boundary.
 * @param argInfo	logical operation (see POPT_ARGFLAG_*)
 * @param aLong		value to use
 * @return		0 on success, POPT_ERROR_NULLARG/POPT_ERROR_BADOPERATION
 */
/*@-incondefs@*/
/*@unused@*/
int poptSaveLong(/*@null@*/ long * arg, unsigned int argInfo, long aLong)
 /*@globals internalState @*/
 /*@modifies *arg, internalState @*/
 /*@requires maxSet(arg) >= 0 /\ maxRead(arg) == 0 @*/;
/*@=incondefs@*/

/**
 * Save an integer, performing logical operation with value.
 * @warning Alignment check may be too strict on certain platorms.
 * @param arg		integer pointer, aligned on int boundary.
 * @param argInfo	logical operation (see POPT_ARGFLAG_*)
 * @param aLong		value to use
 * @return		0 on success, POPT_ERROR_NULLARG/POPT_ERROR_BADOPERATION
 */
/*@-incondefs@*/
/*@unused@*/
int poptSaveInt(/*@null@*/ int * arg, unsigned int argInfo, long aLong)
 /*@globals internalState @*/
 /*@modifies *arg, internalState @*/
 /*@requires maxSet(arg) >= 0 /\ maxRead(arg) == 0 @*/;
/*@=incondefs@*/

/*@=type@*/

}
# 13 "./include/MDCSimulator.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TGlobalLibs.hh" 1


/**************************************************
 *  *** TGLOBALLIBS_HH ***
 *  
 *  Author: Y.Akaike(2011.6.23)
 **************************************************/

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * I/O stream header file iostream.h
 ************************************************************************
 * Description:
 *  CINT iostream header file
 ************************************************************************
 * Copyright(c) 1995~1999  Masaharu Goto 
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
# 11 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream" 2
}
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/_iostream" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// include/_iostream

std::ostream& operator<<(std::ostream& ostr,std::G__CINT_ENDL& i)
 {return(std::endl(ostr));}
std::ostream& operator<<(std::ostream& ostr,std::G__CINT_ENDS& i)
 {return(std::ends(ostr));}
std::ostream& operator<<(std::ostream& ostr,std::G__CINT_FLUSH& i)
 {return(std::flush(ostr));}

std::istream& operator>>(std::istream& istr,std::G__CINT_ws& i)
 {return(std::ws(istr));}
std::istream& operator>>(std::istream& istr,std::G__CINT_WS& i)
 {return(std::WS(istr));}


std::ostream& operator<<(std::ostream& ostr,std::G__CINT_IOFLAGS& f) {
   ostr.setf(f.flag, f.mask);
  return ostr;
}
std::istream& operator>>(std::istream& istr,std::G__CINT_IOFLAGS& f) {
  istr.setf(f.flag, f.mask);
  return istr;
}

std::ostream& operator<<(std::ostream& ostr,std::G__CINT_NOSUPPORT& i) {
  fprintf(stderr,"Limitation: dec,hex,oct manipurator not supported\n");
  return(ostr);
}
std::istream& operator<<(std::istream& istr,std::G__CINT_NOSUPPORT& i) {
  fprintf(stderr,"Limitation: dec,hex,oct manipurator not supported\n");
  return(istr);
}


std::ostream& operator<<(std::ostream& ostr,long long i) {
  char buf[200];
#pragma ifndef G__TMPLTIOS
  if (ostr.flags() & ios::hex)
#pragma else
  if (ostr.flags() & ios_base::hex)
#pragma endif
     sprintf(buf,"%llx",i);
  else
     sprintf(buf,"%lld",i);
  ostr << buf ;
  return(ostr);
}
std::ostream& operator<<(std::ostream& ostr,unsigned long long i) {
  char buf[200];
#pragma ifndef G__TMPLTIOS
  if (ostr.flags() & ios::hex)
#pragma else
  if (ostr.flags() & ios_base::hex)
#pragma endif
     sprintf(buf,"%llx",i);
  else
     sprintf(buf,"%llu",i);
  ostr << buf ;
  return(ostr);
}
std::ostream& operator<<(std::ostream& ostr,long double i) {
  char buf[200];
  sprintf(buf,"%Lg",i);
  ostr << buf ;
  return(ostr);
}
std::istream& operator>>(std::istream& istr,long long &i) {
  char buf[200];
  istr >> buf ;
  sscanf(buf,"%lld",&i);
  return(istr);
}
std::istream& operator>>(std::istream& istr,unsigned long long &i) {
  char buf[200];
  istr >> buf ;
#pragma ifndef G__TMPLTIOS
  if (ostr.flags() & ios::hex)
#pragma else
  if (ostr.flags() & ios_base::hex)
#pragma endif
     sscanf(buf,"%llx",&i);
  else
     sscanf(buf,"%llu",&i);
  return(istr);
}
std::istream& operator>>(std::istream& istr,long double &i) {
  char buf[200];
  istr >> buf ;
  sscanf(buf,"%Lg",&i);
  return(istr);
}


// Value evaluation
//template<class T> int G__ateval(const T* x) {return(0);}
//template<class T> int G__ateval(const T& x) {return(0);}
int G__ateval(const char* const &x) {return(0);}
//int G__ateval(const void* const &x) {return(0);}
int G__ateval(double x) {return(0);}
int G__ateval(float x) {return(0);}
int G__ateval(bool x) {return(0);}
int G__ateval(char x) {return(0);}
int G__ateval(short x) {return(0);}
int G__ateval(int x) {return(0);}
int G__ateval(long x) {return(0);}
int G__ateval(unsigned char x) {return(0);}
int G__ateval(unsigned short x) {return(0);}
int G__ateval(unsigned int x) {return(0);}
int G__ateval(unsigned long x) {return(0);}
# 127 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/_iostream"
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iomanip.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * I/O manipulator header for iomanip.h
 ************************************************************************
 * Description:
 *  CINT IOMANIP header file
 ************************************************************************
 * Author                  Masaharu Goto 
 * Copyright(c) 1995~1999  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
# 127 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/_iostream" 2
# 12 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream" 2
# 10 "/nfs/RAID/home/kamio/local/include/TGlobalLibs.hh" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/fstream" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/fstream.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
/*********************************************************************
* fstream.h
*
*********************************************************************/




# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * I/O stream header file iostream.h
 ************************************************************************
 * Description:
 *  CINT iostream header file
 ************************************************************************
 * Copyright(c) 1995~1999  Masaharu Goto 
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
# 17 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/fstream.h" 2
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/fstream" 2
}
# 11 "/nfs/RAID/home/kamio/local/include/TGlobalLibs.hh" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/sstream" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * I/O stream header file iostream.h
 ************************************************************************
 * Description:
 *  CINT iostream header file
 ************************************************************************
 * Copyright(c) 1995~1999  Masaharu Goto 
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/sstream" 2
}
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/string" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_string" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// string
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/string" 2
}
# 11 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/sstream" 2
# 12 "/nfs/RAID/home/kamio/local/include/TGlobalLibs.hh" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/cstdlib" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/stdlib.h" 1



#pragma setstdstruct






typedef unsigned int wchar_t;
#pragma include_noerr <stdfunc.dll>
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/cstdlib" 2
}
# 13 "/nfs/RAID/home/kamio/local/include/TGlobalLibs.hh" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/cstring" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/string.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
/****************************************************************
* string.h
*****************************************************************/
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/cstring" 2
}
# 14 "/nfs/RAID/home/kamio/local/include/TGlobalLibs.hh" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/cmath" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/math.h" 1





#pragma include_noerr <stdfunc.dll>
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/cmath" 2
#pragma include_noerr <stdcxxfunc.dll>
}
# 15 "/nfs/RAID/home/kamio/local/include/TGlobalLibs.hh" 2
# 1 "/usr/include/zlib.h" 1 3 4
/* zlib.h -- interface of the 'zlib' general purpose compression library
  version 1.2.3, July 18th, 2005

  Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.

  Jean-loup Gailly        Mark Adler
  jloup@gzip.org          madler@alumni.caltech.edu


  The data format used by the zlib library is described by RFCs (Request for
  Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
*/




# 1 "/usr/include/zconf.h" 1 3 4
/* zconf.h -- configuration of the zlib compression library
 * Copyright (C) 1995-2005 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* @(#) $Id$ */




/*
 * If you *really* need a unique prefix for all types and library functions,
 * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
 */
# 84 "/usr/include/zconf.h" 3 4
/*
 * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
 * than 64k bytes at a time (needed on systems with 16-bit int).
 */
# 128 "/usr/include/zconf.h" 3 4
/* Some Mac compilers merge all .h files incorrectly: */




/* Maximum value for memLevel in deflateInit2 */
# 142 "/usr/include/zconf.h" 3 4
/* Maximum value for windowBits in deflateInit2 and inflateInit2.
 * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
 * created by gzip. (Files created by minigzip can still be extracted by
 * gzip.)
 */




/* The memory requirements for deflate are (in bytes):
            (1 << (windowBits+2)) +  (1 << (memLevel+9))
 that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
 plus a few kilobytes for small objects. For example, if you want to reduce
 the default memory requirements from 256K to 128K, compile with
     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
 Of course this will generally degrade compression (there's no free lunch).

   The memory requirements for inflate are (in bytes) 1 << windowBits
 that is, 32K for windowBits=15 (default value) plus a few kilobytes
 for small objects.
*/

                        /* Type declarations */
# 174 "/usr/include/zconf.h" 3 4
/* The following definitions for FAR are needed only for MSDOS mixed
 * model programming (small or medium model with some far allocations).
 * This was tested only with MSC; for other MSDOS compilers you may have
 * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
 * just define FAR to be empty.
 */
# 261 "/usr/include/zconf.h" 3 4
typedef unsigned char Byte; /* 8 bits */

typedef unsigned int uInt; /* 16 bits or more */
typedef unsigned long uLong; /* 32 bits or more */





   typedef Byte Bytef;

typedef char charf;
typedef int intf;
typedef uInt uIntf;
typedef uLong uLongf;


   typedef void const *voidpc;
   typedef void *voidpf;
   typedef void *voidp;







# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/sys/types.h" 1 3 4


typedef int pid_t;
typedef unsigned int pid_t;
typedef void* ptr_t;
typedef unsigned long dev_t;
typedef unsigned int gid_t;
typedef unsigned int uid_t;
typedef unsigned int mode_t;
typedef long off_t;
typedef unsigned long ino_t;
typedef unsigned long nlink_t;
typedef unsigned short ushort;
typedef int key_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
# 289 "/usr/include/zconf.h" 2 3 4
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/unistd.h" 1 3 4
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
/****************************************************************
* unistd.h
*****************************************************************/



#pragma include_noerr <systypes.h>



/* NOTE: posix.dl is not generated by default. 
 * Goto $CINTSYSDIR/lib/posix directory and do 'sh setup' if you use UNIX. */

#pragma include_noerr "posix.dll"
# 290 "/usr/include/zconf.h" 2 3 4
# 315 "/usr/include/zconf.h" 3 4
/* MVS linker does not support external names larger than 8 bytes */
# 35 "/usr/include/zlib.h" 2 3 4


extern "C" {





/*
     The 'zlib' compression library provides in-memory compression and
  decompression functions, including integrity checks of the uncompressed
  data.  This version of the library supports only one compression method
  (deflation) but other algorithms will be added later and will have the same
  stream interface.

     Compression can be done in a single step if the buffers are large
  enough (for example if an input file is mmap'ed), or can be done by
  repeated calls of the compression function.  In the latter case, the
  application must provide more input and/or consume the output
  (providing more output space) before each call.

     The compressed data format used by default by the in-memory functions is
  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
  around a deflate stream, which is itself documented in RFC 1951.

     The library also supports reading and writing files in gzip (.gz) format
  with an interface similar to that of stdio using the functions that start
  with "gz".  The gzip format is different from the zlib format.  gzip is a
  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.

     This library can optionally read and write gzip streams in memory as well.

     The zlib format was designed to be compact and fast for use in memory
  and on communications channels.  The gzip format was designed for single-
  file compression on file systems, has a larger header than zlib to maintain
  directory information, and uses a different, slower check method than zlib.

     The library does not install any signal handler. The decoder checks
  the consistency of the compressed data, so the library should never
  crash even in case of corrupted input.
*/

typedef voidpf (*alloc_func) (voidpf opaque, uInt items, uInt size);
typedef void (*free_func) (voidpf opaque, voidpf address);

struct internal_state;

typedef struct z_stream_s {
    Bytef *next_in; /* next input byte */
    uInt avail_in; /* number of bytes available at next_in */
    uLong total_in; /* total nb of input bytes read so far */

    Bytef *next_out; /* next output byte should be put there */
    uInt avail_out; /* remaining free space at next_out */
    uLong total_out; /* total nb of bytes output so far */

    char *msg; /* last error message, NULL if no error */
    struct internal_state *state; /* not visible by applications */

    alloc_func zalloc; /* used to allocate the internal state */
    free_func zfree; /* used to free the internal state */
    voidpf opaque; /* private data object passed to zalloc and zfree */

    int data_type; /* best guess about the data type: binary or text */
    uLong adler; /* adler32 value of the uncompressed data */
    uLong reserved; /* reserved for future use */
} z_stream;

typedef z_stream *z_streamp;

/*
     gzip header information passed to and from zlib routines.  See RFC 1952
  for more details on the meanings of these fields.
*/
typedef struct gz_header_s {
    int text; /* true if compressed data believed to be text */
    uLong time; /* modification time */
    int xflags; /* extra flags (not used when writing a gzip file) */
    int os; /* operating system */
    Bytef *extra; /* pointer to extra field or Z_NULL if none */
    uInt extra_len; /* extra field length (valid if extra != Z_NULL) */
    uInt extra_max; /* space at extra (only when reading header) */
    Bytef *name; /* pointer to zero-terminated file name or Z_NULL */
    uInt name_max; /* space at name (only when reading header) */
    Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */
    uInt comm_max; /* space at comment (only when reading header) */
    int hcrc; /* true if there was or will be a header crc */
    int done; /* true when done reading gzip header (not used
                           when writing a gzip file) */
} gz_header;

typedef gz_header *gz_headerp;

/*
   The application must update next_in and avail_in when avail_in has
   dropped to zero. It must update next_out and avail_out when avail_out
   has dropped to zero. The application must initialize zalloc, zfree and
   opaque before calling the init function. All other fields are set by the
   compression library and must not be updated by the application.

   The opaque value provided by the application will be passed as the first
   parameter for calls of zalloc and zfree. This can be useful for custom
   memory management. The compression library attaches no meaning to the
   opaque value.

   zalloc must return Z_NULL if there is not enough memory for the object.
   If zlib is used in a multi-threaded application, zalloc and zfree must be
   thread safe.

   On 16-bit systems, the functions zalloc and zfree must be able to allocate
   exactly 65536 bytes, but will not be required to allocate more than this
   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
   pointers returned by zalloc for objects of exactly 65536 bytes *must*
   have their offset normalized to zero. The default allocation function
   provided by this library ensures this (see zutil.c). To reduce memory
   requirements and avoid any allocation of 64K objects, at the expense of
   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).

   The fields total_in and total_out can be used for statistics or
   progress reports. After compression, total_in holds the total size of
   the uncompressed data and may be saved for use in the decompressor
   (particularly if the decompressor wants to decompress everything in
   a single step).
*/

                        /* constants */







/* Allowed flush values; see deflate() and inflate() below for details */
# 179 "/usr/include/zlib.h" 3 4
/* Return codes for the compression/decompression functions. Negative
 * values are errors, positive values are used for special but normal events.
 */





/* compression levels */






/* compression strategy; see deflateInit2() below for details */





/* Possible values of the data_type field (though see inflate()) */


/* The deflate compression method (the only one supported in this version) */




/* for compatibility with versions < 1.0.2 */

                        /* basic functions */

extern const char * zlibVersion (void);
/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
   If the first character differs, the library code actually used is
   not compatible with the zlib.h header file used by the application.
   This check is automatically made by deflateInit and inflateInit.
 */

/*
ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));

     Initializes the internal stream state for compression. The fields
   zalloc, zfree and opaque must be initialized before by the caller.
   If zalloc and zfree are set to Z_NULL, deflateInit updates them to
   use default allocation functions.

     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
   1 gives best speed, 9 gives best compression, 0 gives no compression at
   all (the input data is simply copied a block at a time).
   Z_DEFAULT_COMPRESSION requests a default compromise between speed and
   compression (currently equivalent to level 6).

     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
   enough memory, Z_STREAM_ERROR if level is not a valid compression level,
   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
   with the version assumed by the caller (ZLIB_VERSION).
   msg is set to null if there is no error message.  deflateInit does not
   perform any compression: this will be done by deflate().
*/


extern int deflate (z_streamp strm, int flush);
/*
    deflate compresses as much data as possible, and stops when the input
  buffer becomes empty or the output buffer becomes full. It may introduce some
  output latency (reading input without producing any output) except when
  forced to flush.

    The detailed semantics are as follows. deflate performs one or both of the
  following actions:

  - Compress more input starting at next_in and update next_in and avail_in
    accordingly. If not all input can be processed (because there is not
    enough room in the output buffer), next_in and avail_in are updated and
    processing will resume at this point for the next call of deflate().

  - Provide more output starting at next_out and update next_out and avail_out
    accordingly. This action is forced if the parameter flush is non zero.
    Forcing flush frequently degrades the compression ratio, so this parameter
    should be set only when necessary (in interactive applications).
    Some output may be provided even if flush is not set.

  Before the call of deflate(), the application should ensure that at least
  one of the actions is possible, by providing more input and/or consuming
  more output, and updating avail_in or avail_out accordingly; avail_out
  should never be zero before the call. The application can consume the
  compressed output when it wants, for example when the output buffer is full
  (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
  and with zero avail_out, it must be called again after making room in the
  output buffer because there might be more output pending.

    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
  decide how much data to accumualte before producing output, in order to
  maximize compression.

    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
  flushed to the output buffer and the output is aligned on a byte boundary, so
  that the decompressor can get all input data available so far. (In particular
  avail_in is zero after the call if enough output space has been provided
  before the call.)  Flushing may degrade compression for some compression
  algorithms and so it should be used only when necessary.

    If flush is set to Z_FULL_FLUSH, all output is flushed as with
  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
  restart from this point if previous compressed data has been damaged or if
  random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
  compression.

    If deflate returns with avail_out == 0, this function must be called again
  with the same value of the flush parameter and more output space (updated
  avail_out), until the flush is complete (deflate returns with non-zero
  avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
  avail_out is greater than six to avoid repeated flush markers due to
  avail_out == 0 on return.

    If the parameter flush is set to Z_FINISH, pending input is processed,
  pending output is flushed and deflate returns with Z_STREAM_END if there
  was enough output space; if deflate returns with Z_OK, this function must be
  called again with Z_FINISH and more output space (updated avail_out) but no
  more input data, until it returns with Z_STREAM_END or an error. After
  deflate has returned Z_STREAM_END, the only possible operations on the
  stream are deflateReset or deflateEnd.

    Z_FINISH can be used immediately after deflateInit if all the compression
  is to be done in a single step. In this case, avail_out must be at least
  the value returned by deflateBound (see below). If deflate does not return
  Z_STREAM_END, then it must be called again as described above.

    deflate() sets strm->adler to the adler32 checksum of all input read
  so far (that is, total_in bytes).

    deflate() may update strm->data_type if it can make a good guess about
  the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered
  binary. This field is only for information purposes and does not affect
  the compression algorithm in any manner.

    deflate() returns Z_OK if some progress has been made (more input
  processed or more output produced), Z_STREAM_END if all input has been
  consumed and all output has been produced (only when flush is set to
  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
  if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
  (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
  fatal, and deflate() can be called again with more input and more output
  space to continue compressing.
*/


extern int deflateEnd (z_streamp strm);
/*
     All dynamically allocated data structures for this stream are freed.
   This function discards any unprocessed input and does not flush any
   pending output.

     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
   prematurely (some input or output was discarded). In the error case,
   msg may be set but then points to a static string (which must not be
   deallocated).
*/


/*
ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));

     Initializes the internal stream state for decompression. The fields
   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
   the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
   value depends on the compression method), inflateInit determines the
   compression method from the zlib header and allocates all data structures
   accordingly; otherwise the allocation will be deferred to the first call of
   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
   use default allocation functions.

     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
   version assumed by the caller.  msg is set to null if there is no error
   message. inflateInit does not perform any decompression apart from reading
   the zlib header if present: this will be done by inflate().  (So next_in and
   avail_in may be modified, but next_out and avail_out are unchanged.)
*/


extern int inflate (z_streamp strm, int flush);
/*
    inflate decompresses as much data as possible, and stops when the input
  buffer becomes empty or the output buffer becomes full. It may introduce
  some output latency (reading input without producing any output) except when
  forced to flush.

  The detailed semantics are as follows. inflate performs one or both of the
  following actions:

  - Decompress more input starting at next_in and update next_in and avail_in
    accordingly. If not all input can be processed (because there is not
    enough room in the output buffer), next_in is updated and processing
    will resume at this point for the next call of inflate().

  - Provide more output starting at next_out and update next_out and avail_out
    accordingly.  inflate() provides as much output as possible, until there
    is no more input data or no more space in the output buffer (see below
    about the flush parameter).

  Before the call of inflate(), the application should ensure that at least
  one of the actions is possible, by providing more input and/or consuming
  more output, and updating the next_* and avail_* values accordingly.
  The application can consume the uncompressed output when it wants, for
  example when the output buffer is full (avail_out == 0), or after each
  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
  must be called again after making room in the output buffer because there
  might be more output pending.

    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH,
  Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much
  output as possible to the output buffer. Z_BLOCK requests that inflate() stop
  if and when it gets to the next deflate block boundary. When decoding the
  zlib or gzip format, this will cause inflate() to return immediately after
  the header and before the first block. When doing a raw inflate, inflate()
  will go ahead and process the first block, and will return when it gets to
  the end of that block, or when it runs out of data.

    The Z_BLOCK option assists in appending to or combining deflate streams.
  Also to assist in this, on return inflate() will set strm->data_type to the
  number of unused bits in the last byte taken from strm->next_in, plus 64
  if inflate() is currently decoding the last block in the deflate stream,
  plus 128 if inflate() returned immediately after decoding an end-of-block
  code or decoding the complete header up to just before the first byte of the
  deflate stream. The end-of-block will not be indicated until all of the
  uncompressed data from that block has been written to strm->next_out.  The
  number of unused bits may in general be greater than seven, except when
  bit 7 of data_type is set, in which case the number of unused bits will be
  less than eight.

    inflate() should normally be called until it returns Z_STREAM_END or an
  error. However if all decompression is to be performed in a single step
  (a single call of inflate), the parameter flush should be set to
  Z_FINISH. In this case all pending input is processed and all pending
  output is flushed; avail_out must be large enough to hold all the
  uncompressed data. (The size of the uncompressed data may have been saved
  by the compressor for this purpose.) The next operation on this stream must
  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
  is never required, but can be used to inform inflate that a faster approach
  may be used for the single inflate() call.

     In this implementation, inflate() always flushes as much output as
  possible to the output buffer, and always uses the faster approach on the
  first call. So the only effect of the flush parameter in this implementation
  is on the return value of inflate(), as noted below, or when it returns early
  because Z_BLOCK is used.

     If a preset dictionary is needed after this call (see inflateSetDictionary
  below), inflate sets strm->adler to the adler32 checksum of the dictionary
  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
  strm->adler to the adler32 checksum of all output produced so far (that is,
  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
  below. At the end of the stream, inflate() checks that its computed adler32
  checksum is equal to that saved by the compressor and returns Z_STREAM_END
  only if the checksum is correct.

    inflate() will decompress and check either zlib-wrapped or gzip-wrapped
  deflate data.  The header type is detected automatically.  Any information
  contained in the gzip header is not retained, so applications that need that
  information should instead use raw inflate, see inflateInit2() below, or
  inflateBack() and perform their own processing of the gzip header and
  trailer.

    inflate() returns Z_OK if some progress has been made (more input processed
  or more output produced), Z_STREAM_END if the end of the compressed data has
  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
  corrupted (input stream not conforming to the zlib format or incorrect check
  value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
  if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory,
  Z_BUF_ERROR if no progress is possible or if there was not enough room in the
  output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
  inflate() can be called again with more input and more output space to
  continue decompressing. If Z_DATA_ERROR is returned, the application may then
  call inflateSync() to look for a good compression block if a partial recovery
  of the data is desired.
*/


extern int inflateEnd (z_streamp strm);
/*
     All dynamically allocated data structures for this stream are freed.
   This function discards any unprocessed input and does not flush any
   pending output.

     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
   was inconsistent. In the error case, msg may be set but then points to a
   static string (which must not be deallocated).
*/

                        /* Advanced functions */

/*
    The following functions are needed only in some special applications.
*/

/*
ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
                                     int  level,
                                     int  method,
                                     int  windowBits,
                                     int  memLevel,
                                     int  strategy));

     This is another version of deflateInit with more compression options. The
   fields next_in, zalloc, zfree and opaque must be initialized before by
   the caller.

     The method parameter is the compression method. It must be Z_DEFLATED in
   this version of the library.

     The windowBits parameter is the base two logarithm of the window size
   (the size of the history buffer). It should be in the range 8..15 for this
   version of the library. Larger values of this parameter result in better
   compression at the expense of memory usage. The default value is 15 if
   deflateInit is used instead.

     windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
   determines the window size. deflate() will then generate raw deflate data
   with no zlib header or trailer, and will not compute an adler32 check value.

     windowBits can also be greater than 15 for optional gzip encoding. Add
   16 to windowBits to write a simple gzip header and trailer around the
   compressed data instead of a zlib wrapper. The gzip header will have no
   file name, no extra data, no comment, no modification time (set to zero),
   no header crc, and the operating system will be set to 255 (unknown).  If a
   gzip stream is being written, strm->adler is a crc32 instead of an adler32.

     The memLevel parameter specifies how much memory should be allocated
   for the internal compression state. memLevel=1 uses minimum memory but
   is slow and reduces compression ratio; memLevel=9 uses maximum memory
   for optimal speed. The default value is 8. See zconf.h for total memory
   usage as a function of windowBits and memLevel.

     The strategy parameter is used to tune the compression algorithm. Use the
   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
   string match), or Z_RLE to limit match distances to one (run-length
   encoding). Filtered data consists mostly of small values with a somewhat
   random distribution. In this case, the compression algorithm is tuned to
   compress them better. The effect of Z_FILTERED is to force more Huffman
   coding and less string matching; it is somewhat intermediate between
   Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as
   Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy
   parameter only affects the compression ratio but not the correctness of the
   compressed output even if it is not set appropriately.  Z_FIXED prevents the
   use of dynamic Huffman codes, allowing for a simpler decoder for special
   applications.

      deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
   memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
   method). msg is set to null if there is no error message.  deflateInit2 does
   not perform any compression: this will be done by deflate().
*/

extern int deflateSetDictionary (z_streamp strm, const Bytef *dictionary, uInt dictLength)

                                                               ;
/*
     Initializes the compression dictionary from the given byte sequence
   without producing any compressed output. This function must be called
   immediately after deflateInit, deflateInit2 or deflateReset, before any
   call of deflate. The compressor and decompressor must use exactly the same
   dictionary (see inflateSetDictionary).

     The dictionary should consist of strings (byte sequences) that are likely
   to be encountered later in the data to be compressed, with the most commonly
   used strings preferably put towards the end of the dictionary. Using a
   dictionary is most useful when the data to be compressed is short and can be
   predicted with good accuracy; the data can then be compressed better than
   with the default empty dictionary.

     Depending on the size of the compression data structures selected by
   deflateInit or deflateInit2, a part of the dictionary may in effect be
   discarded, for example if the dictionary is larger than the window size in
   deflate or deflate2. Thus the strings most likely to be useful should be
   put at the end of the dictionary, not at the front. In addition, the
   current implementation of deflate will use at most the window size minus
   262 bytes of the provided dictionary.

     Upon return of this function, strm->adler is set to the adler32 value
   of the dictionary; the decompressor may later use this value to determine
   which dictionary has been used by the compressor. (The adler32 value
   applies to the whole dictionary even if only a subset of the dictionary is
   actually used by the compressor.) If a raw deflate was requested, then the
   adler32 value is not computed and strm->adler is not set.

     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
   parameter is invalid (such as NULL dictionary) or the stream state is
   inconsistent (for example if deflate has already been called for this stream
   or if the compression method is bsort). deflateSetDictionary does not
   perform any compression: this will be done by deflate().
*/

extern int deflateCopy (z_streamp dest, z_streamp source)
                                                      ;
/*
     Sets the destination stream as a complete copy of the source stream.

     This function can be useful when several compression strategies will be
   tried, for example when there are several ways of pre-processing the input
   data with a filter. The streams that will be discarded should then be freed
   by calling deflateEnd.  Note that deflateCopy duplicates the internal
   compression state which can be quite large, so this strategy is slow and
   can consume lots of memory.

     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
   (such as zalloc being NULL). msg is left unchanged in both source and
   destination.
*/

extern int deflateReset (z_streamp strm);
/*
     This function is equivalent to deflateEnd followed by deflateInit,
   but does not free and reallocate all the internal compression state.
   The stream will keep the same compression level and any other attributes
   that may have been set by deflateInit2.

      deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
   stream state was inconsistent (such as zalloc or state being NULL).
*/

extern int deflateParams (z_streamp strm, int level, int strategy)

                                                    ;
/*
     Dynamically update the compression level and compression strategy.  The
   interpretation of level and strategy is as in deflateInit2.  This can be
   used to switch between compression and straight copy of the input data, or
   to switch to a different kind of input data requiring a different
   strategy. If the compression level is changed, the input available so far
   is compressed with the old level (and may be flushed); the new level will
   take effect only at the next call of deflate().

     Before the call of deflateParams, the stream state must be set as for
   a call of deflate(), since the currently available input may have to
   be compressed and flushed. In particular, strm->avail_out must be non-zero.

     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
   if strm->avail_out was zero.
*/

extern int deflateTune (z_streamp strm, int good_length, int max_lazy, int nice_length, int max_chain)



                                                   ;
/*
     Fine tune deflate's internal compression parameters.  This should only be
   used by someone who understands the algorithm used by zlib's deflate for
   searching for the best matching string, and even then only by the most
   fanatic optimizer trying to squeeze out the last compressed bit for their
   specific input data.  Read the deflate.c source code for the meaning of the
   max_lazy, good_length, nice_length, and max_chain parameters.

     deflateTune() can be called after deflateInit() or deflateInit2(), and
   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
 */

extern uLong deflateBound (z_streamp strm, uLong sourceLen)
                                                        ;
/*
     deflateBound() returns an upper bound on the compressed size after
   deflation of sourceLen bytes.  It must be called after deflateInit()
   or deflateInit2().  This would be used to allocate an output buffer
   for deflation in a single pass, and so would be called before deflate().
*/

extern int deflatePrime (z_streamp strm, int bits, int value)

                                                ;
/*
     deflatePrime() inserts bits in the deflate output stream.  The intent
  is that this function is used to start off the deflate output with the
  bits leftover from a previous deflate stream when appending to it.  As such,
  this function can only be used for raw deflate, and must be used before the
  first deflate() call after a deflateInit2() or deflateReset().  bits must be
  less than or equal to 16, and that many of the least significant bits of
  value will be inserted in the output.

      deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
   stream state was inconsistent.
*/

extern int deflateSetHeader (z_streamp strm, gz_headerp head)
                                                          ;
/*
      deflateSetHeader() provides gzip header information for when a gzip
   stream is requested by deflateInit2().  deflateSetHeader() may be called
   after deflateInit2() or deflateReset() and before the first call of
   deflate().  The text, time, os, extra field, name, and comment information
   in the provided gz_header structure are written to the gzip header (xflag is
   ignored -- the extra flags are set according to the compression level).  The
   caller must assure that, if not Z_NULL, name and comment are terminated with
   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
   available there.  If hcrc is true, a gzip header crc is included.  Note that
   the current versions of the command-line version of gzip (up through version
   1.3.x) do not support header crc's, and will report that it is a "multi-part
   gzip file" and give up.

      If deflateSetHeader is not used, the default gzip header has text false,
   the time set to zero, and os set to 255, with no extra, name, or comment
   fields.  The gzip header is returned to the default state by deflateReset().

      deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
   stream state was inconsistent.
*/

/*
ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
                                     int  windowBits));

     This is another version of inflateInit with an extra parameter. The
   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
   before by the caller.

     The windowBits parameter is the base two logarithm of the maximum window
   size (the size of the history buffer).  It should be in the range 8..15 for
   this version of the library. The default value is 15 if inflateInit is used
   instead. windowBits must be greater than or equal to the windowBits value
   provided to deflateInit2() while compressing, or it must be equal to 15 if
   deflateInit2() was not used. If a compressed stream with a larger window
   size is given as input, inflate() will return with the error code
   Z_DATA_ERROR instead of trying to allocate a larger window.

     windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
   determines the window size. inflate() will then process raw deflate data,
   not looking for a zlib or gzip header, not generating a check value, and not
   looking for any check values for comparison at the end of the stream. This
   is for use with other formats that use the deflate compressed data format
   such as zip.  Those formats provide their own check values. If a custom
   format is developed using the raw deflate format for compressed data, it is
   recommended that a check value such as an adler32 or a crc32 be applied to
   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
   most applications, the zlib format should be used as is. Note that comments
   above on the use in deflateInit2() applies to the magnitude of windowBits.

     windowBits can also be greater than 15 for optional gzip decoding. Add
   32 to windowBits to enable zlib and gzip decoding with automatic header
   detection, or add 16 to decode only the gzip format (the zlib format will
   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is
   a crc32 instead of an adler32.

     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
   memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg
   is set to null if there is no error message.  inflateInit2 does not perform
   any decompression apart from reading the zlib header if present: this will
   be done by inflate(). (So next_in and avail_in may be modified, but next_out
   and avail_out are unchanged.)
*/

extern int inflateSetDictionary (z_streamp strm, const Bytef *dictionary, uInt dictLength)

                                                               ;
/*
     Initializes the decompression dictionary from the given uncompressed byte
   sequence. This function must be called immediately after a call of inflate,
   if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
   can be determined from the adler32 value returned by that call of inflate.
   The compressor and decompressor must use exactly the same dictionary (see
   deflateSetDictionary).  For raw inflate, this function can be called
   immediately after inflateInit2() or inflateReset() and before any call of
   inflate() to set the dictionary.  The application must insure that the
   dictionary that was used for compression is provided.

     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
   parameter is invalid (such as NULL dictionary) or the stream state is
   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
   expected one (incorrect adler32 value). inflateSetDictionary does not
   perform any decompression: this will be done by subsequent calls of
   inflate().
*/

extern int inflateSync (z_streamp strm);
/*
    Skips invalid compressed data until a full flush point (see above the
  description of deflate with Z_FULL_FLUSH) can be found, or until all
  available input is skipped. No output is provided.

    inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
  if no more input was provided, Z_DATA_ERROR if no flush point has been found,
  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
  case, the application may save the current current value of total_in which
  indicates where valid compressed data was found. In the error case, the
  application may repeatedly call inflateSync, providing more input each time,
  until success or end of the input data.
*/

extern int inflateCopy (z_streamp dest, z_streamp source)
                                                      ;
/*
     Sets the destination stream as a complete copy of the source stream.

     This function can be useful when randomly accessing a large stream.  The
   first pass through the stream can periodically record the inflate state,
   allowing restarting inflate at those points when randomly accessing the
   stream.

     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
   (such as zalloc being NULL). msg is left unchanged in both source and
   destination.
*/

extern int inflateReset (z_streamp strm);
/*
     This function is equivalent to inflateEnd followed by inflateInit,
   but does not free and reallocate all the internal decompression state.
   The stream will keep attributes that may have been set by inflateInit2.

      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
   stream state was inconsistent (such as zalloc or state being NULL).
*/

extern int inflatePrime (z_streamp strm, int bits, int value)

                                                ;
/*
     This function inserts bits in the inflate input stream.  The intent is
  that this function is used to start inflating at a bit position in the
  middle of a byte.  The provided bits will be used before any bytes are used
  from next_in.  This function should only be used with raw inflate, and
  should be used before the first inflate() call after inflateInit2() or
  inflateReset().  bits must be less than or equal to 16, and that many of the
  least significant bits of value will be inserted in the input.

      inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
   stream state was inconsistent.
*/

extern int inflateGetHeader (z_streamp strm, gz_headerp head)
                                                          ;
/*
      inflateGetHeader() requests that gzip header information be stored in the
   provided gz_header structure.  inflateGetHeader() may be called after
   inflateInit2() or inflateReset(), and before the first call of inflate().
   As inflate() processes the gzip stream, head->done is zero until the header
   is completed, at which time head->done is set to one.  If a zlib stream is
   being decoded, then head->done is set to -1 to indicate that there will be
   no gzip header information forthcoming.  Note that Z_BLOCK can be used to
   force inflate() to return immediately after header processing is complete
   and before any actual data is decompressed.

      The text, time, xflags, and os fields are filled in with the gzip header
   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
   was valid if done is set to one.)  If extra is not Z_NULL, then extra_max
   contains the maximum number of bytes to write to extra.  Once done is true,
   extra_len contains the actual extra field length, and extra contains the
   extra field, or that field truncated if extra_max is less than extra_len.
   If name is not Z_NULL, then up to name_max characters are written there,
   terminated with a zero unless the length is greater than name_max.  If
   comment is not Z_NULL, then up to comm_max characters are written there,
   terminated with a zero unless the length is greater than comm_max.  When
   any of extra, name, or comment are not Z_NULL and the respective field is
   not present in the header, then that field is set to Z_NULL to signal its
   absence.  This allows the use of deflateSetHeader() with the returned
   structure to duplicate the header.  However if those fields are set to
   allocated memory, then the application will need to save those pointers
   elsewhere so that they can be eventually freed.

      If inflateGetHeader is not used, then the header information is simply
   discarded.  The header is always checked for validity, including the header
   CRC if present.  inflateReset() will reset the process to discard the header
   information.  The application would need to call inflateGetHeader() again to
   retrieve the header from the next gzip stream.

      inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
   stream state was inconsistent.
*/

/*
ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
                                        unsigned char FAR *window));

     Initialize the internal stream state for decompression using inflateBack()
   calls.  The fields zalloc, zfree and opaque in strm must be initialized
   before the call.  If zalloc and zfree are Z_NULL, then the default library-
   derived memory allocation routines are used.  windowBits is the base two
   logarithm of the window size, in the range 8..15.  window is a caller
   supplied buffer of that size.  Except for special applications where it is
   assured that deflate was used with small window sizes, windowBits must be 15
   and a 32K byte window must be supplied to be able to decompress general
   deflate streams.

     See inflateBack() for the usage of these routines.

     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
   the paramaters are invalid, Z_MEM_ERROR if the internal state could not
   be allocated, or Z_VERSION_ERROR if the version of the library does not
   match the version of the header file.
*/

typedef unsigned (*in_func) (void *, unsigned char * *);
typedef int (*out_func) (void *, unsigned char *, unsigned);

extern int inflateBack (z_streamp strm, in_func in, void *in_desc, out_func out, void *out_desc)

                                                                      ;
/*
     inflateBack() does a raw inflate with a single call using a call-back
   interface for input and output.  This is more efficient than inflate() for
   file i/o applications in that it avoids copying between the output and the
   sliding window by simply making the window itself the output buffer.  This
   function trusts the application to not change the output buffer passed by
   the output function, at least until inflateBack() returns.

     inflateBackInit() must be called first to allocate the internal state
   and to initialize the state with the user-provided window buffer.
   inflateBack() may then be used multiple times to inflate a complete, raw
   deflate stream with each call.  inflateBackEnd() is then called to free
   the allocated state.

     A raw deflate stream is one with no zlib or gzip header or trailer.
   This routine would normally be used in a utility that reads zip or gzip
   files and writes out uncompressed files.  The utility would decode the
   header and process the trailer on its own, hence this routine expects
   only the raw deflate stream to decompress.  This is different from the
   normal behavior of inflate(), which expects either a zlib or gzip header and
   trailer around the deflate stream.

     inflateBack() uses two subroutines supplied by the caller that are then
   called by inflateBack() for input and output.  inflateBack() calls those
   routines until it reads a complete deflate stream and writes out all of the
   uncompressed data, or until it encounters an error.  The function's
   parameters and return types are defined above in the in_func and out_func
   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
   number of bytes of provided input, and a pointer to that input in buf.  If
   there is no input available, in() must return zero--buf is ignored in that
   case--and inflateBack() will return a buffer error.  inflateBack() will call
   out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].  out()
   should return zero on success, or non-zero on failure.  If out() returns
   non-zero, inflateBack() will return with an error.  Neither in() nor out()
   are permitted to change the contents of the window provided to
   inflateBackInit(), which is also the buffer that out() uses to write from.
   The length written by out() will be at most the window size.  Any non-zero
   amount of input may be provided by in().

     For convenience, inflateBack() can be provided input on the first call by
   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
   in() will be called.  Therefore strm->next_in must be initialized before
   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
   must also be initialized, and then if strm->avail_in is not zero, input will
   initially be taken from strm->next_in[0 .. strm->avail_in - 1].

     The in_desc and out_desc parameters of inflateBack() is passed as the
   first parameter of in() and out() respectively when they are called.  These
   descriptors can be optionally used to pass any information that the caller-
   supplied in() and out() functions need to do their job.

     On return, inflateBack() will set strm->next_in and strm->avail_in to
   pass back any unused input that was provided by the last in() call.  The
   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
   if in() or out() returned an error, Z_DATA_ERROR if there was a format
   error in the deflate stream (in which case strm->msg is set to indicate the
   nature of the error), or Z_STREAM_ERROR if the stream was not properly
   initialized.  In the case of Z_BUF_ERROR, an input or output error can be
   distinguished using strm->next_in which will be Z_NULL only if in() returned
   an error.  If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to
   out() returning non-zero.  (in() will always be called before out(), so
   strm->next_in is assured to be defined if out() returns non-zero.)  Note
   that inflateBack() cannot return Z_OK.
*/

extern int inflateBackEnd (z_streamp strm);
/*
     All memory allocated by inflateBackInit() is freed.

     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
   state was inconsistent.
*/

extern uLong zlibCompileFlags (void);
/* Return flags indicating compile-time options.

    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
     1.0: size of uInt
     3.2: size of uLong
     5.4: size of voidpf (pointer)
     7.6: size of z_off_t

    Compiler, assembler, and debug options:
     8: DEBUG
     9: ASMV or ASMINF -- use ASM code
     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
     11: 0 (reserved)

    One-time table building (smaller code, but not thread-safe if true):
     12: BUILDFIXED -- build static block decoding tables when needed
     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
     14,15: 0 (reserved)

    Library content (indicates missing functionality):
     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
                          deflate code when not needed)
     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
                    and decode gzip streams (to avoid linking crc code)
     18-19: 0 (reserved)

    Operation variations (changes in library functionality):
     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
     21: FASTEST -- deflate algorithm with only one, lowest compression level
     22,23: 0 (reserved)

    The sprintf variant used by gzprintf (zero is best):
     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
     26: 0 = returns value, 1 = void -- 1 means inferred string length returned

    Remainder:
     27-31: 0 (reserved)
 */


                        /* utility functions */

/*
     The following utility functions are implemented on top of the
   basic stream-oriented functions. To simplify the interface, some
   default options are assumed (compression level and memory usage,
   standard memory allocation functions). The source code of these
   utility functions can easily be modified if you need special options.
*/

extern int compress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
                                                                       ;
/*
     Compresses the source buffer into the destination buffer.  sourceLen is
   the byte length of the source buffer. Upon entry, destLen is the total
   size of the destination buffer, which must be at least the value returned
   by compressBound(sourceLen). Upon exit, destLen is the actual size of the
   compressed buffer.
     This function can be used to compress a whole file at once if the
   input file is mmap'ed.
     compress returns Z_OK if success, Z_MEM_ERROR if there was not
   enough memory, Z_BUF_ERROR if there was not enough room in the output
   buffer.
*/

extern int compress2 (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level)

                                             ;
/*
     Compresses the source buffer into the destination buffer. The level
   parameter has the same meaning as in deflateInit.  sourceLen is the byte
   length of the source buffer. Upon entry, destLen is the total size of the
   destination buffer, which must be at least the value returned by
   compressBound(sourceLen). Upon exit, destLen is the actual size of the
   compressed buffer.

     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
   Z_STREAM_ERROR if the level parameter is invalid.
*/

extern uLong compressBound (uLong sourceLen);
/*
     compressBound() returns an upper bound on the compressed size after
   compress() or compress2() on sourceLen bytes.  It would be used before
   a compress() or compress2() call to allocate the destination buffer.
*/

extern int uncompress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
                                                                         ;
/*
     Decompresses the source buffer into the destination buffer.  sourceLen is
   the byte length of the source buffer. Upon entry, destLen is the total
   size of the destination buffer, which must be large enough to hold the
   entire uncompressed data. (The size of the uncompressed data must have
   been saved previously by the compressor and transmitted to the decompressor
   by some mechanism outside the scope of this compression library.)
   Upon exit, destLen is the actual size of the compressed buffer.
     This function can be used to decompress a whole file at once if the
   input file is mmap'ed.

     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
   enough memory, Z_BUF_ERROR if there was not enough room in the output
   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.
*/


typedef voidp gzFile;

extern gzFile gzopen (const char *path, const char *mode);
/*
     Opens a gzip (.gz) file for reading or writing. The mode parameter
   is as in fopen ("rb" or "wb") but can also include a compression level
   ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
   Huffman only compression as in "wb1h", or 'R' for run-length encoding
   as in "wb1R". (See the description of deflateInit2 for more information
   about the strategy parameter.)

     gzopen can be used to read a file which is not in gzip format; in this
   case gzread will directly read from the file without decompression.

     gzopen returns NULL if the file could not be opened or if there was
   insufficient memory to allocate the (de)compression state; errno
   can be checked to distinguish the two cases (if errno is zero, the
   zlib error is Z_MEM_ERROR).  */

extern gzFile gzdopen (int fd, const char *mode);
/*
     gzdopen() associates a gzFile with the file descriptor fd.  File
   descriptors are obtained from calls like open, dup, creat, pipe or
   fileno (in the file has been previously opened with fopen).
   The mode parameter is as in gzopen.
     The next call of gzclose on the returned gzFile will also close the
   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
     gzdopen returns NULL if there was insufficient memory to allocate
   the (de)compression state.
*/

extern int gzsetparams (gzFile file, int level, int strategy);
/*
     Dynamically update the compression level or strategy. See the description
   of deflateInit2 for the meaning of these parameters.
     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
   opened for writing.
*/

extern int gzread (gzFile file, voidp buf, unsigned len);
/*
     Reads the given number of uncompressed bytes from the compressed file.
   If the input file was not in gzip format, gzread copies the given number
   of bytes into the buffer.
     gzread returns the number of uncompressed bytes actually read (0 for
   end of file, -1 for error). */

extern int gzwrite (gzFile file, voidpc buf, unsigned len)
                                                             ;
/*
     Writes the given number of uncompressed bytes into the compressed file.
   gzwrite returns the number of uncompressed bytes actually written
   (0 in case of error).
*/

extern int gzprintf (gzFile file, const char *format, ...);
/*
     Converts, formats, and writes the args to the compressed file under
   control of the format string, as in fprintf. gzprintf returns the number of
   uncompressed bytes actually written (0 in case of error).  The number of
   uncompressed bytes written is limited to 4095. The caller should assure that
   this limit is not exceeded. If it is exceeded, then gzprintf() will return
   return an error (0) with nothing written. In this case, there may also be a
   buffer overflow with unpredictable consequences, which is possible only if
   zlib was compiled with the insecure functions sprintf() or vsprintf()
   because the secure snprintf() or vsnprintf() functions were not available.
*/

extern int gzputs (gzFile file, const char *s);
/*
      Writes the given null-terminated string to the compressed file, excluding
   the terminating null character.
      gzputs returns the number of characters written, or -1 in case of error.
*/

extern char * gzgets (gzFile file, char *buf, int len);
/*
      Reads bytes from the compressed file until len-1 characters are read, or
   a newline character is read and transferred to buf, or an end-of-file
   condition is encountered.  The string is then terminated with a null
   character.
      gzgets returns buf, or Z_NULL in case of error.
*/

extern int gzputc (gzFile file, int c);
/*
      Writes c, converted to an unsigned char, into the compressed file.
   gzputc returns the value that was written, or -1 in case of error.
*/

extern int gzgetc (gzFile file);
/*
      Reads one byte from the compressed file. gzgetc returns this byte
   or -1 in case of end of file or error.
*/

extern int gzungetc (int c, gzFile file);
/*
      Push one character back onto the stream to be read again later.
   Only one character of push-back is allowed.  gzungetc() returns the
   character pushed, or -1 on failure.  gzungetc() will fail if a
   character has been pushed but not read yet, or if c is -1. The pushed
   character will be discarded if the stream is repositioned with gzseek()
   or gzrewind().
*/

extern int gzflush (gzFile file, int flush);
/*
     Flushes all pending output into the compressed file. The parameter
   flush is as in the deflate() function. The return value is the zlib
   error number (see function gzerror below). gzflush returns Z_OK if
   the flush parameter is Z_FINISH and all output could be flushed.
     gzflush should be called only when strictly necessary because it can
   degrade compression.
*/

extern off_t gzseek (gzFile file, off_t offset, int whence)
                                                                  ;
/*
      Sets the starting position for the next gzread or gzwrite on the
   given compressed file. The offset represents a number of bytes in the
   uncompressed data stream. The whence parameter is defined as in lseek(2);
   the value SEEK_END is not supported.
     If the file is opened for reading, this function is emulated but can be
   extremely slow. If the file is opened for writing, only forward seeks are
   supported; gzseek then compresses a sequence of zeroes up to the new
   starting position.

      gzseek returns the resulting offset location as measured in bytes from
   the beginning of the uncompressed stream, or -1 in case of error, in
   particular if the file is opened for writing and the new starting position
   would be before the current position.
*/

extern int gzrewind (gzFile file);
/*
     Rewinds the given file. This function is supported only for reading.

   gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
*/

extern off_t gztell (gzFile file);
/*
     Returns the starting position for the next gzread or gzwrite on the
   given compressed file. This position represents a number of bytes in the
   uncompressed data stream.

   gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
*/

extern int gzeof (gzFile file);
/*
     Returns 1 when EOF has previously been detected reading the given
   input stream, otherwise zero.
*/

extern int gzdirect (gzFile file);
/*
     Returns 1 if file is being read directly without decompression, otherwise
   zero.
*/

extern int gzclose (gzFile file);
/*
     Flushes all pending output if necessary, closes the compressed file
   and deallocates all the (de)compression state. The return value is the zlib
   error number (see function gzerror below).
*/

extern const char * gzerror (gzFile file, int *errnum);
/*
     Returns the error message for the last error which occurred on the
   given compressed file. errnum is set to zlib error number. If an
   error occurred in the file system and not in the compression library,
   errnum is set to Z_ERRNO and the application may consult errno
   to get the exact error code.
*/

extern void gzclearerr (gzFile file);
/*
     Clears the error and end-of-file flags for file. This is analogous to the
   clearerr() function in stdio. This is useful for continuing to read a gzip
   file that is being written concurrently.
*/

                        /* checksum functions */

/*
     These functions are not related to compression but are exported
   anyway because they might be useful in applications using the
   compression library.
*/

extern uLong adler32 (uLong adler, const Bytef *buf, uInt len);
/*
     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
   return the updated checksum. If buf is NULL, this function returns
   the required initial value for the checksum.
   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
   much faster. Usage example:

     uLong adler = adler32(0L, Z_NULL, 0);

     while (read_buffer(buffer, length) != EOF) {
       adler = adler32(adler, buffer, length);
     }
     if (adler != original_adler) error();
*/

extern uLong adler32_combine (uLong adler1, uLong adler2, off_t len2)
                                                        ;
/*
     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.
*/

extern uLong crc32 (uLong crc, const Bytef *buf, uInt len);
/*
     Update a running CRC-32 with the bytes buf[0..len-1] and return the
   updated CRC-32. If buf is NULL, this function returns the required initial
   value for the for the crc. Pre- and post-conditioning (one's complement) is
   performed within this function so it shouldn't be done by the application.
   Usage example:

     uLong crc = crc32(0L, Z_NULL, 0);

     while (read_buffer(buffer, length) != EOF) {
       crc = crc32(crc, buffer, length);
     }
     if (crc != original_crc) error();
*/

extern uLong crc32_combine (uLong crc1, uLong crc2, off_t len2);

/*
     Combine two CRC-32 check values into one.  For two sequences of bytes,
   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
   len2.
*/


                        /* various hacks, don't look :) */

/* deflateInit and inflateInit are macros to allow checking the zlib version
 * and the compiler's view of z_stream:
 */
extern int deflateInit_ (z_streamp strm, int level, const char *version, int stream_size)
                                                                           ;
extern int inflateInit_ (z_streamp strm, const char *version, int stream_size)
                                                                           ;
extern int deflateInit2_ (z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size)


                                                       ;
extern int inflateInit2_ (z_streamp strm, int windowBits, const char *version, int stream_size)
                                                                            ;
extern int inflateBackInit_ (z_streamp strm, int windowBits, unsigned char *window, const char *version, int stream_size)


                                                          ;
# 1346 "/usr/include/zlib.h" 3 4
    struct internal_state {int dummy;}; /* hack for buggy compilers */


extern const char * zError (int);
extern int inflateSyncPoint (z_streamp z);
extern const uLongf * get_crc_table (void);


}
# 16 "/nfs/RAID/home/kamio/local/include/TGlobalLibs.hh" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iomanip" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iomanip.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * I/O manipulator header for iomanip.h
 ************************************************************************
 * Description:
 *  CINT IOMANIP header file
 ************************************************************************
 * Author                  Masaharu Goto 
 * Copyright(c) 1995~1999  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iomanip" 2
}
# 17 "/nfs/RAID/home/kamio/local/include/TGlobalLibs.hh" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/sys/stat.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
/* POSIX dummy file */
# 18 "/nfs/RAID/home/kamio/local/include/TGlobalLibs.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 1
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TApplication.h" 1
// @(#)root/base:$Id: TApplication.h 39402 2011-05-26 12:56:31Z axel $
// Author: Fons Rademakers   22/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TApplication                                                         //
//                                                                      //
// This class creates the ROOT Application Environment that interfaces  //
// to the windowing system eventloop and eventhandlers.                 //
// This class must be instantiated exactly once in any given            //
// application. Normally the specific application class inherits from   //
// TApplication (see TRint).                                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////






# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TQObject.h" 1
// @(#)root/base:$Id: TQObject.h 22791 2008-03-20 15:33:49Z rdm $
// Author: Valeriy Onuchin & Fons Rademakers   15/10/2000

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// This is the ROOT implementation of the Qt object communication       //
// mechanism (see also http://www.troll.no/qt/metaobjects.html)         //
//                                                                      //
// Signals and slots are used for communication between objects.        //
// When an object has changed in some way that might be interesting     //
// for the outside world, it emits a signal to tell whoever is          //
// listening. All slots that are connected to this signal will be       //
// activated (called).  It is even possible to connect a signal         //
// directly to  another signal (this will emit the second signal        //
// immediately whenever the first is emitted.) There is no limitation   //
// on the number of slots that can be connected to a signal.            //
// The slots will be activated in the order they were connected         //
// to the signal. This mechanism allows objects to be easily reused,    //
// because the object that emits a signal does not need to know         //
// to what the signals are connected to.                                //
// Together, signals and slots make up a powerfull component            //
// programming mechanism.                                               //
//                                                                      //
// This implementation is provided by                                   //
// Valeriy Onuchin (onuchin@sirius.ihep.su).                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TString.h" 1
// @(#)root/base:$Id: TString.h 43133 2012-02-27 09:50:10Z rdm $
// Author: Fons Rademakers   04/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TString                                                              //
//                                                                      //
// Basic string class.                                                  //
//                                                                      //
// Cannot be stored in a TCollection... use TObjString instead.         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 36 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TString.h"
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMathBase.h" 1
// @(#)root/base:$Id: TMathBase.h 20877 2007-11-19 11:17:07Z rdm $
// Authors: Rene Brun, Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMath Base functions                                                 //
//                                                                      //
// Define the functions Min, Max, Abs, Sign, Range for all types.       //
// NB: These functions are unfortunately not available in a portable    //
// way in std::.                                                        //
//                                                                      //
// More functions are defined in TMath.h. TMathBase.h is designed to be //
// a stable file and used in place of TMath.h in the ROOT miniCore.     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





namespace TMath {

   // Abs
   inline Short_t Abs(Short_t d);
   inline Int_t Abs(Int_t d);
   inline Long_t Abs(Long_t d);
   inline Long64_t Abs(Long64_t d);
   inline Float_t Abs(Float_t d);
   inline Double_t Abs(Double_t d);

   // Even/Odd
   inline Bool_t Even(Long_t a);
   inline Bool_t Odd(Long_t a);

   // Sign
   inline Short_t Sign(Short_t a, Short_t b);
   inline Int_t Sign(Int_t a, Int_t b);
   inline Long_t Sign(Long_t a, Long_t b);
   inline Long64_t Sign(Long64_t a, Long64_t b);
   inline Float_t Sign(Float_t a, Float_t b);
   inline Double_t Sign(Double_t a, Double_t b);

   // Min, Max of two scalars
   inline Short_t Min(Short_t a, Short_t b);
   inline UShort_t Min(UShort_t a, UShort_t b);
   inline Int_t Min(Int_t a, Int_t b);
   inline UInt_t Min(UInt_t a, UInt_t b);
   inline Long_t Min(Long_t a, Long_t b);
   inline ULong_t Min(ULong_t a, ULong_t b);
   inline Long64_t Min(Long64_t a, Long64_t b);
   inline ULong64_t Min(ULong64_t a, ULong64_t b);
   inline Float_t Min(Float_t a, Float_t b);
   inline Double_t Min(Double_t a, Double_t b);

   inline Short_t Max(Short_t a, Short_t b);
   inline UShort_t Max(UShort_t a, UShort_t b);
   inline Int_t Max(Int_t a, Int_t b);
   inline UInt_t Max(UInt_t a, UInt_t b);
   inline Long_t Max(Long_t a, Long_t b);
   inline ULong_t Max(ULong_t a, ULong_t b);
   inline Long64_t Max(Long64_t a, Long64_t b);
   inline ULong64_t Max(ULong64_t a, ULong64_t b);
   inline Float_t Max(Float_t a, Float_t b);
   inline Double_t Max(Double_t a, Double_t b);

   // Range
   inline Short_t Range(Short_t lb, Short_t ub, Short_t x);
   inline Int_t Range(Int_t lb, Int_t ub, Int_t x);
   inline Long_t Range(Long_t lb, Long_t ub, Long_t x);
   inline ULong_t Range(ULong_t lb, ULong_t ub, ULong_t x);
   inline Double_t Range(Double_t lb, Double_t ub, Double_t x);

   //NextPrime is used by the Core classes.
   Long_t NextPrime(Long_t x); // Least prime number greater than x
}


//---- Even/odd ----------------------------------------------------------------

inline Bool_t TMath::Even(Long_t a)
   { return ! (a & 1); }

inline Bool_t TMath::Odd(Long_t a)
   { return (a & 1); }

//---- Abs ---------------------------------------------------------------------

inline Short_t TMath::Abs(Short_t d)
   { return (d >= 0) ? d : -d; }

inline Int_t TMath::Abs(Int_t d)
   { return (d >= 0) ? d : -d; }

inline Long_t TMath::Abs(Long_t d)
   { return (d >= 0) ? d : -d; }

inline Long64_t TMath::Abs(Long64_t d)
   { return (d >= 0) ? d : -d; }

inline Float_t TMath::Abs(Float_t d)
   { return (d >= 0) ? d : -d; }

inline Double_t TMath::Abs(Double_t d)
   { return (d >= 0) ? d : -d; }

//---- Sign --------------------------------------------------------------------

inline Short_t TMath::Sign(Short_t a, Short_t b)
   { return (b >= 0) ? Abs(a) : -Abs(a); }

inline Int_t TMath::Sign(Int_t a, Int_t b)
   { return (b >= 0) ? Abs(a) : -Abs(a); }

inline Long_t TMath::Sign(Long_t a, Long_t b)
   { return (b >= 0) ? Abs(a) : -Abs(a); }

inline Long64_t TMath::Sign(Long64_t a, Long64_t b)
   { return (b >= 0) ? Abs(a) : -Abs(a); }

inline Float_t TMath::Sign(Float_t a, Float_t b)
   { return (b >= 0) ? Abs(a) : -Abs(a); }

inline Double_t TMath::Sign(Double_t a, Double_t b)
   { return (b >= 0) ? Abs(a) : -Abs(a); }

//---- Min ---------------------------------------------------------------------

inline Short_t TMath::Min(Short_t a, Short_t b)
   { return a <= b ? a : b; }

inline UShort_t TMath::Min(UShort_t a, UShort_t b)
   { return a <= b ? a : b; }

inline Int_t TMath::Min(Int_t a, Int_t b)
   { return a <= b ? a : b; }

inline UInt_t TMath::Min(UInt_t a, UInt_t b)
   { return a <= b ? a : b; }

inline Long_t TMath::Min(Long_t a, Long_t b)
   { return a <= b ? a : b; }

inline ULong_t TMath::Min(ULong_t a, ULong_t b)
   { return a <= b ? a : b; }

inline Long64_t TMath::Min(Long64_t a, Long64_t b)
   { return a <= b ? a : b; }

inline ULong64_t TMath::Min(ULong64_t a, ULong64_t b)
   { return a <= b ? a : b; }

inline Float_t TMath::Min(Float_t a, Float_t b)
   { return a <= b ? a : b; }

inline Double_t TMath::Min(Double_t a, Double_t b)
   { return a <= b ? a : b; }

//---- Max ---------------------------------------------------------------------

inline Short_t TMath::Max(Short_t a, Short_t b)
   { return a >= b ? a : b; }

inline UShort_t TMath::Max(UShort_t a, UShort_t b)
   { return a >= b ? a : b; }

inline Int_t TMath::Max(Int_t a, Int_t b)
   { return a >= b ? a : b; }

inline UInt_t TMath::Max(UInt_t a, UInt_t b)
   { return a >= b ? a : b; }

inline Long_t TMath::Max(Long_t a, Long_t b)
   { return a >= b ? a : b; }

inline ULong_t TMath::Max(ULong_t a, ULong_t b)
   { return a >= b ? a : b; }

inline Long64_t TMath::Max(Long64_t a, Long64_t b)
   { return a >= b ? a : b; }

inline ULong64_t TMath::Max(ULong64_t a, ULong64_t b)
   { return a >= b ? a : b; }

inline Float_t TMath::Max(Float_t a, Float_t b)
   { return a >= b ? a : b; }

inline Double_t TMath::Max(Double_t a, Double_t b)
   { return a >= b ? a : b; }

//---- Range -------------------------------------------------------------------

inline Short_t TMath::Range(Short_t lb, Short_t ub, Short_t x)
   { return x < lb ? lb : (x > ub ? ub : x); }

inline Int_t TMath::Range(Int_t lb, Int_t ub, Int_t x)
   { return x < lb ? lb : (x > ub ? ub : x); }

inline Long_t TMath::Range(Long_t lb, Long_t ub, Long_t x)
   { return x < lb ? lb : (x > ub ? ub : x); }

inline ULong_t TMath::Range(ULong_t lb, ULong_t ub, ULong_t x)
   { return x < lb ? lb : (x > ub ? ub : x); }

inline Double_t TMath::Range(Double_t lb, Double_t ub, Double_t x)
   { return x < lb ? lb : (x > ub ? ub : x); }
# 37 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TString.h" 2


# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/stdarg.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
/****************************************************************
* stdarg.h
*****************************************************************/
# 40 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TString.h" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/string" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_string" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// string
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/string" 2
}
# 41 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TString.h" 2





class TRegexp;
class TPRegexp;
class TString;
class TSubString;
class TObjArray;
class TVirtualMutex;

extern TVirtualMutex *gStringMutex;

TString operator+(const TString &s1, const TString &s2);
TString operator+(const TString &s, const char *cs);
TString operator+(const char *cs, const TString &s);
TString operator+(const TString &s, char c);
TString operator+(const TString &s, Long_t i);
TString operator+(const TString &s, ULong_t i);
TString operator+(const TString &s, Long64_t i);
TString operator+(const TString &s, ULong64_t i);
TString operator+(char c, const TString &s);
TString operator+(Long_t i, const TString &s);
TString operator+(ULong_t i, const TString &s);
TString operator+(Long64_t i, const TString &s);
TString operator+(ULong64_t i, const TString &s);
Bool_t operator==(const TString &s1, const TString &s2);
Bool_t operator==(const TString &s1, const char *s2);
Bool_t operator==(const TSubString &s1, const TSubString &s2);
Bool_t operator==(const TSubString &s1, const TString &s2);
Bool_t operator==(const TSubString &s1, const char *s2);


//////////////////////////////////////////////////////////////////////////
//                                                                      //
//  TSubString                                                          //
//                                                                      //
//  The TSubString class allows selected elements to be addressed.      //
//  There are no public constructors.                                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
class TSubString {

friend class TStringLong;
friend class TString;

friend Bool_t operator==(const TSubString &s1, const TSubString &s2);
friend Bool_t operator==(const TSubString &s1, const TString &s2);
friend Bool_t operator==(const TSubString &s1, const char *s2);

private:
   TString &fStr; // Referenced string
   Ssiz_t fBegin; // Index of starting character
   Ssiz_t fExtent; // Length of TSubString

   // NB: the only constructor is private
   TSubString(const TString &s, Ssiz_t start, Ssiz_t len);

protected:
   void SubStringError(Ssiz_t, Ssiz_t, Ssiz_t) const;
   void AssertElement(Ssiz_t i) const; // Verifies i is valid index

public:
   TSubString(const TSubString &s)
     : fStr(s.fStr), fBegin(s.fBegin), fExtent(s.fExtent) { }

   TSubString &operator=(const char *s); // Assignment from a char*
   TSubString &operator=(const TString &s); // Assignment from a TString
   TSubString &operator=(const TSubString &s); // Assignment from a TSubString
   char &operator()(Ssiz_t i); // Index with optional bounds checking
   char &operator[](Ssiz_t i); // Index with bounds checking
   char operator()(Ssiz_t i) const; // Index with optional bounds checking
   char operator[](Ssiz_t i) const; // Index with bounds checking

   const char *Data() const;
   Ssiz_t Length() const { return fExtent; }
   Ssiz_t Start() const { return fBegin; }
   TString& String() { return fStr; }
   void ToLower(); // Convert self to lower-case
   void ToUpper(); // Convert self to upper-case

   // For detecting null substrings
   Bool_t IsNull() const { return fBegin == kNPOS; }
   int operator!() const { return fBegin == kNPOS; }
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
//  TString                                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
class TString {

friend class TStringLong;
friend class TSubString;

friend TString operator+(const TString &s1, const TString &s2);
friend TString operator+(const TString &s, const char *cs);
friend TString operator+(const char *cs, const TString &s);
friend TString operator+(const TString &s, char c);
friend TString operator+(const TString &s, Long_t i);
friend TString operator+(const TString &s, ULong_t i);
friend TString operator+(const TString &s, Long64_t i);
friend TString operator+(const TString &s, ULong64_t i);
friend TString operator+(char c, const TString &s);
friend TString operator+(Long_t i, const TString &s);
friend TString operator+(ULong_t i, const TString &s);
friend TString operator+(Long64_t i, const TString &s);
friend TString operator+(ULong64_t i, const TString &s);
friend Bool_t operator==(const TString &s1, const TString &s2);
friend Bool_t operator==(const TString &s1, const char *s2);

private:

   enum { kShortMask = 0x01, kLongMask = 0x1 };




   struct LongStr_t
   {
      Ssiz_t fCap; // Max string length (including null)
      Ssiz_t fSize; // String length (excluding null)
      char *fData; // Long string data
   };

   enum { kMinCap = (sizeof(LongStr_t) - 1)/sizeof(char) > 2 ?
                    (sizeof(LongStr_t) - 1)/sizeof(char) : 2 };

   struct ShortStr_t
   {
      unsigned char fSize; // String length (excluding null)
      char fData[kMinCap]; // Short string data
   };

   union UStr_t { LongStr_t fL; ShortStr_t fS; };

   enum { kNwords = sizeof(UStr_t) / sizeof(Ssiz_t)};

   struct RawStr_t
   {
      Ssiz_t fWords[kNwords];
   };

   struct Rep_t
   {
      union
      {
         LongStr_t fLong;
         ShortStr_t fShort;
         RawStr_t fRaw;
      };
   };

protected:




   // Special concatenation constructor
   TString(const char *a1, Ssiz_t n1, const char *a2, Ssiz_t n2);
   void AssertElement(Ssiz_t nc) const; // Index in range
   void Clobber(Ssiz_t nc); // Remove old contents
   void InitChar(char c); // Initialize from char

   enum { kAlignment = 16 };
   static Ssiz_t Align(Ssiz_t s) { return (s + (kAlignment-1)) & ~(kAlignment-1); }
   static Ssiz_t Recommend(Ssiz_t s) { return (s < kMinCap ? kMinCap : Align(s+1)) - 1; }
   static Ssiz_t AdjustCapacity(Ssiz_t oldCap, Ssiz_t newCap);

private:
   Bool_t IsLong() const { return Bool_t(fRep.fShort.fSize & kShortMask); }

   void SetShortSize(Ssiz_t s) { fRep.fShort.fSize = (unsigned char)(s << 1); }
   Ssiz_t GetShortSize() const { return fRep.fShort.fSize >> 1; }




   void SetLongSize(Ssiz_t s) { fRep.fLong.fSize = s; }
   Ssiz_t GetLongSize() const { return fRep.fLong.fSize; }
   void SetSize(Ssiz_t s) { IsLong() ? SetLongSize(s) : SetShortSize(s); }
   void SetLongCap(Ssiz_t s) { fRep.fLong.fCap = kLongMask | s; }
   Ssiz_t GetLongCap() const { return fRep.fLong.fCap & ~kLongMask; }
   void SetLongPointer(char *p) { fRep.fLong.fData = p; }
   char *GetLongPointer() { return fRep.fLong.fData; }
   const char *GetLongPointer() const { return fRep.fLong.fData; }
   char *GetShortPointer() { return fRep.fShort.fData; }
   const char *GetShortPointer() const { return fRep.fShort.fData; }
   char *GetPointer() { return IsLong() ? GetLongPointer() : GetShortPointer(); }
   const char *GetPointer() const { return IsLong() ? GetLongPointer() : GetShortPointer(); }

   static Ssiz_t MaxSize() { return kMaxInt - 1; }



   void UnLink() const { if (IsLong()) delete [] fRep.fLong.fData; }
   void Zero() {
      Ssiz_t (&a)[kNwords] = fRep.fRaw.fWords;
      for (UInt_t i = 0; i < kNwords; ++i)
         a[i] = 0;
   }
   char *Init(Ssiz_t capacity, Ssiz_t nchar);
   void Clone(Ssiz_t nc); // Make self a distinct copy w. capacity nc
   void FormImp(const char *fmt, va_list ap);
   UInt_t HashCase() const;
   UInt_t HashFoldCase() const;

public:
   enum EStripType { kLeading = 0x1, kTrailing = 0x2, kBoth = 0x3 };
   enum ECaseCompare { kExact, kIgnoreCase };

   TString(); // Null string
   explicit TString(Ssiz_t ic); // Suggested capacity
   TString(const TString &s); // Copy constructor
   TString(const char *s); // Copy to embedded null
   TString(const char *s, Ssiz_t n); // Copy past any embedded nulls
   TString(const std::string &s);
   TString(char c);
   TString(char c, Ssiz_t s);
   TString(const TSubString &sub);

   virtual ~TString();

   // ROOT I/O interface
   virtual void FillBuffer(char *&buffer) const;
   virtual void ReadBuffer(char *&buffer);
   virtual Int_t Sizeof() const;

   static TString *ReadString(TBuffer &b, const TClass *clReq);
   static void WriteString(TBuffer &b, const TString *a);

   friend TBuffer &operator<<(TBuffer &b, const TString *obj);

   // C I/O interface
   Bool_t Gets(FILE *fp, Bool_t chop=kTRUE);
   void Puts(FILE *fp);

   // Type conversion
   operator const char*() const { return GetPointer(); }

   // Assignment
   TString &operator=(char s); // Replace string
   TString &operator=(const char *s);
   TString &operator=(const TString &s);
   TString &operator=(const std::string &s);
   TString &operator=(const TSubString &s);
   TString &operator+=(const char *s); // Append string
   TString &operator+=(const TString &s);
   TString &operator+=(char c);
   TString &operator+=(Short_t i);
   TString &operator+=(UShort_t i);
   TString &operator+=(Int_t i);
   TString &operator+=(UInt_t i);
   TString &operator+=(Long_t i);
   TString &operator+=(ULong_t i);
   TString &operator+=(Float_t f);
   TString &operator+=(Double_t f);
   TString &operator+=(Long64_t i);
   TString &operator+=(ULong64_t i);

   // Indexing operators
   char &operator[](Ssiz_t i); // Indexing with bounds checking
   char &operator()(Ssiz_t i); // Indexing with optional bounds checking
   char operator[](Ssiz_t i) const;
   char operator()(Ssiz_t i) const;
   TSubString operator()(Ssiz_t start, Ssiz_t len) const; // Sub-string operator
   TSubString operator()(const TRegexp &re) const; // Match the RE
   TSubString operator()(const TRegexp &re, Ssiz_t start) const;
   TSubString operator()(TPRegexp &re) const; // Match the Perl compatible Regular Expression
   TSubString operator()(TPRegexp &re, Ssiz_t start) const;
   TSubString SubString(const char *pat, Ssiz_t start = 0,
                           ECaseCompare cmp = kExact) const;

   // Non-static member functions
   TString &Append(const char *cs);
   TString &Append(const char *cs, Ssiz_t n);
   TString &Append(const TString &s);
   TString &Append(const TString &s, Ssiz_t n);
   TString &Append(char c, Ssiz_t rep = 1); // Append c rep times
   Int_t Atoi() const;
   Long64_t Atoll() const;
   Double_t Atof() const;
   Bool_t BeginsWith(const char *s, ECaseCompare cmp = kExact) const;
   Bool_t BeginsWith(const TString &pat, ECaseCompare cmp = kExact) const;
   Ssiz_t Capacity() const { return (IsLong() ? GetLongCap() : kMinCap) - 1; }
   Ssiz_t Capacity(Ssiz_t n);
   TString &Chop();
   void Clear();
   int CompareTo(const char *cs, ECaseCompare cmp = kExact) const;
   int CompareTo(const TString &st, ECaseCompare cmp = kExact) const;
   Bool_t Contains(const char *pat, ECaseCompare cmp = kExact) const;
   Bool_t Contains(const TString &pat, ECaseCompare cmp = kExact) const;
   Bool_t Contains(const TRegexp &pat) const;
   Bool_t Contains(TPRegexp &pat) const;
   Int_t CountChar(Int_t c) const;
   TString Copy() const;
   const char *Data() const { return GetPointer(); }
   Bool_t EndsWith(const char *pat, ECaseCompare cmp = kExact) const;
   Bool_t EqualTo(const char *cs, ECaseCompare cmp = kExact) const;
   Bool_t EqualTo(const TString &st, ECaseCompare cmp = kExact) const;
   Ssiz_t First(char c) const;
   Ssiz_t First(const char *cs) const;
   void Form(const char *fmt, ...)



   ;
   UInt_t Hash(ECaseCompare cmp = kExact) const;
   Ssiz_t Index(const char *pat, Ssiz_t i = 0,
                      ECaseCompare cmp = kExact) const;
   Ssiz_t Index(const TString &s, Ssiz_t i = 0,
                      ECaseCompare cmp = kExact) const;
   Ssiz_t Index(const char *pat, Ssiz_t patlen, Ssiz_t i,
                      ECaseCompare cmp) const;
   Ssiz_t Index(const TString &s, Ssiz_t patlen, Ssiz_t i,
                      ECaseCompare cmp) const;
   Ssiz_t Index(const TRegexp &pat, Ssiz_t i = 0) const;
   Ssiz_t Index(const TRegexp &pat, Ssiz_t *ext, Ssiz_t i = 0) const;
   Ssiz_t Index(TPRegexp &pat, Ssiz_t i = 0) const;
   Ssiz_t Index(TPRegexp &pat, Ssiz_t *ext, Ssiz_t i = 0) const;
   TString &Insert(Ssiz_t pos, const char *s);
   TString &Insert(Ssiz_t pos, const char *s, Ssiz_t extent);
   TString &Insert(Ssiz_t pos, const TString &s);
   TString &Insert(Ssiz_t pos, const TString &s, Ssiz_t extent);
   Bool_t IsAscii() const;
   Bool_t IsAlpha() const;
   Bool_t IsAlnum() const;
   Bool_t IsDigit() const;
   Bool_t IsFloat() const;
   Bool_t IsHex() const;
   Bool_t IsBin() const;
   Bool_t IsOct() const;
   Bool_t IsDec() const;
   Bool_t IsInBaseN(Int_t base) const;
   Bool_t IsNull() const { return Length() == 0; }
   Bool_t IsWhitespace() const { return (Length() == CountChar(' ')); }
   Ssiz_t Last(char c) const;
   Ssiz_t Length() const { return IsLong() ? GetLongSize() : GetShortSize(); }
   Bool_t MaybeRegexp() const;
   Bool_t MaybeWildcard() const;
   TString MD5() const;
   TString &Prepend(const char *cs); // Prepend a character string
   TString &Prepend(const char *cs, Ssiz_t n);
   TString &Prepend(const TString &s);
   TString &Prepend(const TString &s, Ssiz_t n);
   TString &Prepend(char c, Ssiz_t rep = 1); // Prepend c rep times
   istream &ReadFile(istream &str); // Read to EOF or null character
   istream &ReadLine(istream &str,
                         Bool_t skipWhite = kTRUE); // Read to EOF or newline
   istream &ReadString(istream &str); // Read to EOF or null character
   istream &ReadToDelim(istream &str, char delim = '\n'); // Read to EOF or delimitor
   istream &ReadToken(istream &str); // Read separated by white space
   TString &Remove(Ssiz_t pos); // Remove pos to end of string
   TString &Remove(Ssiz_t pos, Ssiz_t n); // Remove n chars starting at pos
   TString &Remove(EStripType s, char c); // Like Strip() but changing string directly
   TString &Replace(Ssiz_t pos, Ssiz_t n, const char *s);
   TString &Replace(Ssiz_t pos, Ssiz_t n, const char *s, Ssiz_t ns);
   TString &Replace(Ssiz_t pos, Ssiz_t n, const TString &s);
   TString &Replace(Ssiz_t pos, Ssiz_t n1, const TString &s, Ssiz_t n2);
   TString &ReplaceAll(const TString &s1, const TString &s2); // Find&Replace all s1 with s2 if any
   TString &ReplaceAll(const TString &s1, const char *s2); // Find&Replace all s1 with s2 if any
   TString &ReplaceAll(const char *s1, const TString &s2); // Find&Replace all s1 with s2 if any
   TString &ReplaceAll(const char *s1, const char *s2); // Find&Replace all s1 with s2 if any
   TString &ReplaceAll(const char *s1, Ssiz_t ls1, const char *s2, Ssiz_t ls2); // Find&Replace all s1 with s2 if any
   void Resize(Ssiz_t n); // Truncate or add blanks as necessary
   TSubString Strip(EStripType s = kTrailing, char c = ' ') const;
   void ToLower(); // Change self to lower-case
   void ToUpper(); // Change self to upper-case
   TObjArray *Tokenize(const TString &delim) const;
   Bool_t Tokenize(TString &tok, Ssiz_t &from, const char *delim = " ") const;

   // Static member functions
   static UInt_t Hash(const void *txt, Int_t ntxt); // Calculates hash index from any char string.
   static Ssiz_t InitialCapacity(Ssiz_t ic = 15); // Initial allocation capacity
   static Ssiz_t MaxWaste(Ssiz_t mw = 15); // Max empty space before reclaim
   static Ssiz_t ResizeIncrement(Ssiz_t ri = 16); // Resizing increment
   static Ssiz_t GetInitialCapacity();
   static Ssiz_t GetResizeIncrement();
   static Ssiz_t GetMaxWaste();
   static TString Itoa ( Int_t value, Int_t base); // Converts int to string with respect to the base specified (2-36)
   static TString UItoa ( UInt_t value, Int_t base);
   static TString LLtoa ( Long64_t value, Int_t base);
   static TString ULLtoa (ULong64_t value, Int_t base);
   static TString BaseConvert(const TString& s_in, Int_t base_in, Int_t base_out); // Converts string from base base_in to base base_out (supported bases 2-36)
   static TString Format(const char *fmt, ...)



   ;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TString::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TString::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TString.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 434; } //Basic string class
};

// Related global functions
istream &operator>>(istream &str, TString &s);
ostream &operator<<(ostream &str, const TString &s);



TBuffer &operator>>(TBuffer &buf, TString *&sp);

TString ToLower(const TString &s); // Return lower-case version of argument
TString ToUpper(const TString &s); // Return upper-case version of argument

inline UInt_t Hash(const TString &s) { return s.Hash(); }
inline UInt_t Hash(const TString *s) { return s->Hash(); }
       UInt_t Hash(const char *s);

extern char *Form(const char *fmt, ...) // format in circular buffer



;
extern void Printf(const char *fmt, ...) // format and print



;
extern char *Strip(const char *str, char c = ' '); // strip c off str, free with delete []
extern char *StrDup(const char *str); // duplicate str, free with delete []
extern char *Compress(const char *str); // remove blanks from string, free with delele []
extern int EscChar(const char *src, char *dst, int dstlen, char *specchars,
                     char escchar); // copy from src to dst escaping specchars by escchar
extern int UnEscChar(const char *src, char *dst, int dstlen, char *specchars,
                       char escchar); // copy from src to dst removing escchar from specchars






//////////////////////////////////////////////////////////////////////////
//                                                                      //
//  Inlines                                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

inline TString &TString::Append(const char *cs)
{ return Replace(Length(), 0, cs, cs ? strlen(cs) : 0); }

inline TString &TString::Append(const char *cs, Ssiz_t n)
{ return Replace(Length(), 0, cs, n); }

inline TString &TString::Append(const TString &s)
{ return Replace(Length(), 0, s.Data(), s.Length()); }

inline TString &TString::Append(const TString &s, Ssiz_t n)
{ return Replace(Length(), 0, s.Data(), TMath::Min(n, s.Length())); }

inline TString &TString::operator+=(const char *cs)
{ return Append(cs, cs ? strlen(cs) : 0); }

inline TString &TString::operator+=(const TString &s)
{ return Append(s.Data(), s.Length()); }

inline TString &TString::operator+=(char c)
{ return Append(c); }

inline TString &TString::operator+=(Long_t i)
{ char s[32]; sprintf(s, "%ld", i); return operator+=(s); }

inline TString &TString::operator+=(ULong_t i)
{ char s[32]; sprintf(s, "%lu", i); return operator+=(s); }

inline TString &TString::operator+=(Short_t i)
{ return operator+=((Long_t) i); }

inline TString &TString::operator+=(UShort_t i)
{ return operator+=((ULong_t) i); }

inline TString &TString::operator+=(Int_t i)
{ return operator+=((Long_t) i); }

inline TString &TString::operator+=(UInt_t i)
{ return operator+=((ULong_t) i); }

inline TString &TString::operator+=(Double_t f)
{
   char s[32];
   // coverity[secure_coding] Buffer is large enough: width specified in format
   sprintf(s, "%.17g", f);
   return operator+=(s);
}

inline TString &TString::operator+=(Float_t f)
{ return operator+=((Double_t) f); }

inline TString &TString::operator+=(Long64_t l)
{
   char s[32];
   // coverity[secure_coding] Buffer is large enough (2^64 = 20 digits).
   sprintf(s, "%lld", l);
   return operator+=(s);
}

inline TString &TString::operator+=(ULong64_t ul)
{
   char s[32];
   // coverity[secure_coding] Buffer is large enough (2^64 = 20 digits).
   sprintf(s, "%llu", ul);
   return operator+=(s);
}

inline Bool_t TString::BeginsWith(const char *s, ECaseCompare cmp) const
{ return Index(s, s ? strlen(s) : (Ssiz_t)0, (Ssiz_t)0, cmp) == 0; }

inline Bool_t TString::BeginsWith(const TString &pat, ECaseCompare cmp) const
{ return Index(pat.Data(), pat.Length(), (Ssiz_t)0, cmp) == 0; }

inline Bool_t TString::Contains(const TString &pat, ECaseCompare cmp) const
{ return Index(pat.Data(), pat.Length(), (Ssiz_t)0, cmp) != kNPOS; }

inline Bool_t TString::Contains(const char *s, ECaseCompare cmp) const
{ return Index(s, s ? strlen(s) : 0, (Ssiz_t)0, cmp) != kNPOS; }

inline Bool_t TString::Contains(const TRegexp &pat) const
{ return Index(pat, (Ssiz_t)0) != kNPOS; }

inline Bool_t TString::Contains(TPRegexp &pat) const
{ return Index(pat, (Ssiz_t)0) != kNPOS; }

inline Bool_t TString::EqualTo(const char *cs, ECaseCompare cmp) const
{ return (CompareTo(cs, cmp) == 0) ? kTRUE : kFALSE; }

inline Bool_t TString::EqualTo(const TString &st, ECaseCompare cmp) const
{ return (CompareTo(st, cmp) == 0) ? kTRUE : kFALSE; }

inline Ssiz_t TString::Index(const char *s, Ssiz_t i, ECaseCompare cmp) const
{ return Index(s, s ? strlen(s) : 0, i, cmp); }

inline Ssiz_t TString::Index(const TString &s, Ssiz_t i, ECaseCompare cmp) const
{ return Index(s.Data(), s.Length(), i, cmp); }

inline Ssiz_t TString::Index(const TString &pat, Ssiz_t patlen, Ssiz_t i,
                             ECaseCompare cmp) const
{ return Index(pat.Data(), patlen, i, cmp); }

inline TString &TString::Insert(Ssiz_t pos, const char *cs)
{ return Replace(pos, 0, cs, cs ? strlen(cs) : 0); }

inline TString &TString::Insert(Ssiz_t pos, const char *cs, Ssiz_t n)
{ return Replace(pos, 0, cs, n); }

inline TString &TString::Insert(Ssiz_t pos, const TString &s)
{ return Replace(pos, 0, s.Data(), s.Length()); }

inline TString &TString::Insert(Ssiz_t pos, const TString &s, Ssiz_t n)
{ return Replace(pos, 0, s.Data(), TMath::Min(n, s.Length())); }

inline TString &TString::Prepend(const char *cs)
{ return Replace(0, 0, cs, cs ? strlen(cs) : 0); }

inline TString &TString::Prepend(const char *cs, Ssiz_t n)
{ return Replace(0, 0, cs, n); }

inline TString &TString::Prepend(const TString &s)
{ return Replace(0, 0, s.Data(), s.Length()); }

inline TString &TString::Prepend(const TString &s, Ssiz_t n)
{ return Replace(0, 0, s.Data(), TMath::Min(n, s.Length())); }

inline TString &TString::Remove(Ssiz_t pos)
{ return Replace(pos, TMath::Max(0, Length()-pos), 0, 0); }

inline TString &TString::Remove(Ssiz_t pos, Ssiz_t n)
{ return Replace(pos, n, 0, 0); }

inline TString &TString::Chop()
{ return Remove(TMath::Max(0, Length()-1)); }

inline TString &TString::Replace(Ssiz_t pos, Ssiz_t n, const char *cs)
{ return Replace(pos, n, cs, cs ? strlen(cs) : 0); }

inline TString &TString::Replace(Ssiz_t pos, Ssiz_t n, const TString& s)
{ return Replace(pos, n, s.Data(), s.Length()); }

inline TString &TString::Replace(Ssiz_t pos, Ssiz_t n1, const TString &s,
                                 Ssiz_t n2)
{ return Replace(pos, n1, s.Data(), TMath::Min(s.Length(), n2)); }

inline TString &TString::ReplaceAll(const TString &s1, const TString &s2)
{ return ReplaceAll(s1.Data(), s1.Length(), s2.Data(), s2.Length()) ; }

inline TString &TString::ReplaceAll(const TString &s1, const char *s2)
{ return ReplaceAll(s1.Data(), s1.Length(), s2, s2 ? strlen(s2) : 0); }

inline TString &TString::ReplaceAll(const char *s1, const TString &s2)
{ return ReplaceAll(s1, s1 ? strlen(s1) : 0, s2.Data(), s2.Length()); }

inline TString &TString::ReplaceAll(const char *s1,const char *s2)
{ return ReplaceAll(s1, s1 ? strlen(s1) : 0, s2, s2 ? strlen(s2) : 0); }

inline char &TString::operator()(Ssiz_t i)
{ return GetPointer()[i]; }

inline char TString::operator()(Ssiz_t i) const
{ return GetPointer()[i]; }

inline char &TString::operator[](Ssiz_t i)
{ AssertElement(i); return GetPointer()[i]; }

inline char TString::operator[](Ssiz_t i) const
{ AssertElement(i); return GetPointer()[i]; }

inline const char *TSubString::Data() const
{
   // Return a pointer to the beginning of the substring. Note that the
   // terminating null is in the same place as for the original
   // TString, so this method is not appropriate for converting the
   // TSubString to a string. To do that, construct a TString from the
   // TSubString. For example:
   //
   //   root [0] TString s("hello world")
   //   root [1] TSubString sub=s(0, 5)
   //   root [2] sub.Data()
   //   (const char* 0x857c8b8)"hello world"
   //   root [3] TString substr(sub)
   //   root [4] substr
   //   (class TString)"hello"

   return fStr.Data() + fBegin;
}

// Access to elements of sub-string with bounds checking
inline char TSubString::operator[](Ssiz_t i) const
{ AssertElement(i); return fStr.GetPointer()[fBegin+i]; }

inline char TSubString::operator()(Ssiz_t i) const
{ return fStr.GetPointer()[fBegin+i]; }

inline TSubString &TSubString::operator=(const TSubString &s)
{ fStr = s.fStr; fBegin = s.fBegin; fExtent = s.fExtent; return *this; }


// String Logical operators
inline Bool_t operator==(const TString &s1, const TString &s2)
{
   return ((s1.Length() == s2.Length()) &&
            !memcmp(s1.Data(), s2.Data(), s1.Length()));
}

inline Bool_t operator!=(const TString &s1, const TString &s2)
{ return !(s1 == s2); }

inline Bool_t operator<(const TString &s1, const TString &s2)
{ return s1.CompareTo(s2) < 0; }

inline Bool_t operator>(const TString &s1, const TString &s2)
{ return s1.CompareTo(s2) > 0; }

inline Bool_t operator<=(const TString &s1, const TString &s2)
{ return s1.CompareTo(s2) <= 0; }

inline Bool_t operator>=(const TString &s1, const TString &s2)
{ return s1.CompareTo(s2) >= 0; }

//     Bool_t operator==(const TString &s1, const char *s2);
inline Bool_t operator!=(const TString &s1, const char *s2)
{ return !(s1 == s2); }

inline Bool_t operator<(const TString &s1, const char *s2)
{ return s1.CompareTo(s2) < 0; }

inline Bool_t operator>(const TString &s1, const char *s2)
{ return s1.CompareTo(s2) > 0; }

inline Bool_t operator<=(const TString &s1, const char *s2)
{ return s1.CompareTo(s2) <= 0; }

inline Bool_t operator>=(const TString &s1, const char *s2)
{ return s1.CompareTo(s2) >= 0; }

inline Bool_t operator==(const char *s1, const TString &s2)
{ return (s2 == s1); }

inline Bool_t operator!=(const char *s1, const TString &s2)
{ return !(s2 == s1); }

inline Bool_t operator<(const char *s1, const TString &s2)
{ return s2.CompareTo(s1) > 0; }

inline Bool_t operator>(const char *s1, const TString &s2)
{ return s2.CompareTo(s1) < 0; }

inline Bool_t operator<=(const char *s1, const TString &s2)
{ return s2.CompareTo(s1) >= 0; }

inline Bool_t operator>=(const char *s1, const TString &s2)
{ return s2.CompareTo(s1) <= 0; }

// SubString Logical operators
//     Bool_t operator==(const TSubString &s1, const TSubString &s2);
//     Bool_t operator==(const TSubString &s1, const char *s2);
//     Bool_t operator==(const TSubString &s1, const TString &s2);
inline Bool_t operator==(const TString &s1, const TSubString &s2)
{ return (s2 == s1); }

inline Bool_t operator==(const char *s1, const TSubString &s2)
{ return (s2 == s1); }

inline Bool_t operator!=(const TSubString &s1, const char *s2)
{ return !(s1 == s2); }

inline Bool_t operator!=(const TSubString &s1, const TString &s2)
{ return !(s1 == s2); }

inline Bool_t operator!=(const TSubString &s1, const TSubString &s2)
{ return !(s1 == s2); }

inline Bool_t operator!=(const TString &s1, const TSubString &s2)
{ return !(s2 == s1); }

inline Bool_t operator!=(const char *s1, const TSubString &s2)
{ return !(s2 == s1); }
# 42 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TQObject.h" 2


class TList;
class TObject;
class TQConnection;
class TClass;

class TQObject {

friend class TQConnection;

protected:
   TList *fListOfSignals; //! list of signals from this object
   TList *fListOfConnections; //! list of connections to this object
   Bool_t fSignalsBlocked; //! flag used for suppression of signals

   static Bool_t fgAllSignalsBlocked; // flag used for suppression of all signals

   virtual void *GetSender() { return this; }
   virtual const char *GetSenderClassName() const { return ""; }

   static Bool_t ConnectToClass(TQObject *sender,
                                const char *signal,
                                TClass *receiver_class,
                                void *receiver,
                                const char *slot);

   static Bool_t ConnectToClass(const char *sender_class,
                                const char *signal,
                                TClass *receiver_class,
                                void *receiver,
                                const char *slot);

   static Int_t CheckConnectArgs(TQObject *sender,
                                 TClass *sender_class, const char *signal,
                                 TClass *receiver_class, const char *slot);

private:
   TQObject(const TQObject& tqo); // not implemented
   TQObject& operator=(const TQObject& tqo); // not implemented

public:
   TQObject();
   virtual ~TQObject();

   TList *GetListOfClassSignals() const;
   TList *GetListOfSignals() const { return fListOfSignals; }
   TList *GetListOfConnections() const { return fListOfConnections; }

   Bool_t AreSignalsBlocked() const { return fSignalsBlocked; }
   Bool_t BlockSignals(Bool_t b)
            { Bool_t ret = fSignalsBlocked; fSignalsBlocked = b; return ret; }

   void CollectClassSignalLists(TList& list, TClass* cls);

   void EmitVA(const char *signal, Int_t nargs, ...);
   void EmitVA(const char *signal, Int_t nargs, va_list va);
   void Emit(const char *signal);
   void Emit(const char *signal, Long_t *paramArr);
   void Emit(const char *signal, const char *params);
   void Emit(const char *signal, Double_t param);
   void Emit(const char *signal, Long_t param);
   void Emit(const char *signal, Long64_t param);
   void Emit(const char *signal, Bool_t param)
         { Emit(signal, (Long_t)param); }
   void Emit(const char *signal, Char_t param)
         { Emit(signal, (Long_t)param); }
   void Emit(const char *signal, UChar_t param)
         { Emit(signal, (Long_t)param); }
   void Emit(const char *signal, Short_t param)
         { Emit(signal, (Long_t)param); }
   void Emit(const char *signal, UShort_t param)
         { Emit(signal, (Long_t)param); }
   void Emit(const char *signal, Int_t param)
         { Emit(signal, (Long_t)param); }
   void Emit(const char *signal, UInt_t param)
         { Emit(signal, (Long_t)param); }
   void Emit(const char *signal, ULong_t param)
         { Emit(signal, (Long_t)param); }
   void Emit(const char *signal, ULong64_t param)
         { Emit(signal, (Long64_t) param); }
   void Emit(const char *signal, Float_t param)
         { Emit(signal, (Double_t)param); }

   Bool_t Connect(const char *signal,
                  const char *receiver_class,
                  void *receiver,
                  const char *slot);

   Bool_t Disconnect(const char *signal = 0,
                     void *receiver = 0,
                     const char *slot = 0);

   virtual void HighPriority(const char *signal_name,
                               const char *slot_name = 0);

   virtual void LowPriority(const char *signal_name,
                              const char *slot_name = 0);

   virtual Bool_t HasConnection(const char *signal_name) const;
   virtual Int_t NumberOfSignals() const;
   virtual Int_t NumberOfConnections() const;
   virtual void Connected(const char * /*signal_name*/) { }
   virtual void Disconnected(const char * /*signal_name*/) { }

   virtual void Destroyed()
                  { Emit("Destroyed()"); } // *SIGNAL*
   virtual void ChangedBy(const char *method)
                  { Emit("ChangedBy(char*)", method); } // *SIGNAL*
   virtual void Message(const char *msg)
                  { Emit("Message(char*)", msg); } // *SIGNAL*

   static Bool_t Connect(TQObject *sender,
                          const char *signal,
                          const char *receiver_class,
                          void *receiver,
                          const char *slot);

   static Bool_t Connect(const char *sender_class,
                          const char *signal,
                          const char *receiver_class,
                          void *receiver,
                          const char *slot);

   static Bool_t Disconnect(TQObject *sender,
                             const char *signal = 0,
                             void *receiver = 0,
                             const char *slot = 0);

   static Bool_t Disconnect(const char *class_name,
                             const char *signal,
                             void *receiver = 0,
                             const char *slot = 0);

   static Bool_t AreAllSignalsBlocked();
   static Bool_t BlockAllSignals(Bool_t b);

   static void LoadRQ_OBJECT();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TQObject::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TQObject::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TQObject.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 181; } //Base class for object communication mechanism
};


extern void *gTQSender; // the latest sender object

class TQObjSender : public TQObject {

protected:
   void *fSender; //delegation object
   TString fSenderClass; //class name of delegation object

   virtual void *GetSender() { return fSender; }
   virtual const char *GetSenderClassName() const { return fSenderClass; }

private:
   TQObjSender(const TQObjSender&); // not implemented
   TQObjSender& operator=(const TQObjSender&); // not implemented

public:
   TQObjSender() : TQObject(), fSender(0), fSenderClass() { }
   virtual ~TQObjSender() { Disconnect(); }

   virtual void SetSender(void *sender) { fSender = sender; }
   void SetSenderClassName(const char *sclass = "") { fSenderClass = sclass; }

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TQObjSender::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TQObjSender::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TQObject.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 207; } //Used to "delegate" TQObject functionality
                           //to interpreted classes, see also RQ_OBJECT.h
};

// Global function which simplifies making connections in interpreted
// ROOT session
//
//  ConnectCINT      - connects to interpreter(CINT) command

extern Bool_t ConnectCINT(TQObject *sender, const char *signal,
                          const char *slot);
# 227 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TQObject.h"
//---- ClassImpQ macro ----------------------------------------------
//
// This macro used to correspond to the ClassImp macro and should be used
// for classes derived from TQObject instead of the ClassImp macro.
// This macro makes it possible to have a single connection from
// all objects of the same class.
// *** It is now obsolete ***
# 34 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TApplication.h" 2



# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TApplicationImp.h" 1
// @(#)root/base:$Id: TApplicationImp.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Fons Rademakers   22/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TApplicationImp                                                      //
//                                                                      //
// ABC describing GUI independent application implementation protocol.  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TGWin32Command;


class TApplicationImp {

protected:
   TString fApplicationName; // application name

public:
   TApplicationImp(): fApplicationName() { }
   TApplicationImp(const char *appClassName, int *argc, char **argv);
   virtual ~TApplicationImp() { }

   virtual const char *ApplicationName() const { return fApplicationName.Data(); }
   virtual void Show() { }
   virtual void Hide() { }
   virtual void Iconify() { }
   virtual Bool_t IsCmdThread() { return kTRUE; } // by default (for UNIX) ROOT is a single thread application
   virtual void Init() { }
   virtual void Open() { }
   virtual void Raise() { }
   virtual void Lower() { }
   virtual Int_t ExecCommand(TGWin32Command *code, Bool_t synch);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TApplicationImp::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TApplicationImp::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TApplicationImp.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 52; } //ABC describing application protocol
};

inline TApplicationImp::TApplicationImp(const char *appClassName, int *, char **)
  : fApplicationName(appClassName) { }
inline Int_t TApplicationImp::ExecCommand(TGWin32Command *, Bool_t) { return 0; }
# 38 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TApplication.h" 2


class TObjArray;
class TTimer;
class TSignalHandler;


class TApplication : public TObject, public TQObject {

public:
   // TApplication specific bits
   enum EStatusBits {
      kProcessRemotely = (1ULL << (15)), // TRUE if this line has to be processed remotely
      kDefaultApplication = (1ULL << (16)) // TRUE if created via CreateApplication()
   };
   enum EExitOnException {
      kDontExit,
      kExit,
      kAbort
   };

private:
   Int_t fArgc; //Number of com   mand line arguments
   char **fArgv; //Command line arguments
   TApplicationImp *fAppImp; //!Window system specific application implementation
   Bool_t fIsRunning; //True when in event loop (Run() has been called)
   Bool_t fReturnFromRun; //When true return from Run()
   Bool_t fNoLog; //Do not process logon and logoff macros
   Bool_t fNoLogo; //Do not show splash screen and welcome message
   Bool_t fQuit; //Exit after having processed input files
   Bool_t fUseMemstat; //Run with TMemStat enabled
   TObjArray *fFiles; //Array of input files (TObjString's) specified via argv
   TString fWorkDir; //Working directory specified via argv
   TString fIdleCommand; //Command to execute while application is idle
   TTimer *fIdleTimer; //Idle timer
   TSignalHandler *fSigHandler; //Interrupt handler
   EExitOnException fExitOnException; //Exit on exception option

   static Bool_t fgGraphNeeded; // True if graphics libs need to be initialized
   static Bool_t fgGraphInit; // True if graphics libs initialized

   TApplication(const TApplication&); // not implemented
   TApplication& operator=(const TApplication&); // not implemented

protected:
   TApplication *fAppRemote; //Current remote application, if defined

   static TList *fgApplications; //List of available applications

   TApplication();

   virtual Long_t ProcessRemote(const char *line, Int_t *error = 0);
   virtual void Help(const char *line);
   virtual void LoadGraphicsLibs();
   virtual void MakeBatch();
   void SetSignalHandler(TSignalHandler *sh) { fSigHandler = sh; }

   static Int_t ParseRemoteLine(const char *ln,
                                      TString &hostdir, TString &user,
                                      Int_t &dbg, TString &script);
   static TApplication *Open(const char *url, Int_t debug, const char *script);
   static void Close(TApplication *app);

public:
   TApplication(const char *appClassName, Int_t *argc, char **argv,
                void *options = 0, Int_t numOptions = 0);
   virtual ~TApplication();

   void InitializeGraphics();
   virtual void GetOptions(Int_t *argc, char **argv);
   TSignalHandler *GetSignalHandler() const { return fSigHandler; }
   virtual void SetEchoMode(Bool_t mode);

   virtual void HandleException(Int_t sig);
   virtual void HandleIdleTimer(); //*SIGNAL*
   virtual Bool_t HandleTermInput() { return kFALSE; }
   virtual void Init() { fAppImp->Init(); }
   virtual Long_t ProcessLine(const char *line, Bool_t sync = kFALSE, Int_t *error = 0);
   virtual Long_t ProcessFile(const char *file, Int_t *error = 0, Bool_t keep = kFALSE);
   virtual void Run(Bool_t retrn = kFALSE);
   virtual void SetIdleTimer(UInt_t idleTimeInSec, const char *command);
   virtual void RemoveIdleTimer();
   const char *GetIdleCommand() const { return fIdleCommand; }
   virtual void StartIdleing();
   virtual void StopIdleing();
   EExitOnException ExitOnException(EExitOnException opt = kExit);

   virtual const char *ApplicationName() const { return fAppImp->ApplicationName(); }
   virtual void Show() { fAppImp->Show(); }
   virtual void Hide() { fAppImp->Hide(); }
   virtual void Iconify() { fAppImp->Iconify(); }
   virtual void Open() { fAppImp->Open(); }
   virtual void Raise() { fAppImp->Raise(); }
   virtual void Lower() { fAppImp->Lower(); }
   virtual Bool_t IsCmdThread() { return fAppImp ? fAppImp->IsCmdThread() : kTRUE; }
   virtual TApplicationImp *GetApplicationImp() { return fAppImp;}

   virtual void ls(Option_t *option="") const;

   Int_t Argc() const { return fArgc; }
   char **Argv() const { return fArgv; }
   char *Argv(Int_t index) const;
   Bool_t NoLogOpt() const { return fNoLog; }
   Bool_t NoLogoOpt() const { return fNoLogo; }
   Bool_t QuitOpt() const { return fQuit; }
   TObjArray *InputFiles() const { return fFiles; }
   const char *WorkingDirectory() const { return fWorkDir; }
   void ClearInputFiles();

   TApplication *GetAppRemote() const { return fAppRemote; }

   Bool_t IsRunning() const { return fIsRunning; }
   Bool_t ReturnFromRun() const { return fReturnFromRun; }
   void SetReturnFromRun(Bool_t ret) { fReturnFromRun = ret; }

   virtual void LineProcessed(const char *line); //*SIGNAL*
   virtual void Terminate(Int_t status = 0); //*SIGNAL*
   virtual void KeyPressed(Int_t key); //*SIGNAL*
   virtual void ReturnPressed(char *text ); //*SIGNAL*
   virtual Int_t TabCompletionHook(char *buf, int *pLoc, ostream& out);

   static Long_t ExecuteFile(const char *file, Int_t *error = 0, Bool_t keep = kFALSE);
   static TList *GetApplications();
   static void CreateApplication();
   static void NeedGraphicsLibs();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TApplication::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TApplication::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TApplication.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 164; } //GUI application singleton
};

extern TApplication *gApplication;
# 2 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFile.h" 1
// @(#)root/io:$Id: TFile.h 42754 2012-01-20 20:13:07Z pcanal $
// Author: Rene Brun   28/11/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TFile                                                                //
//                                                                      //
// ROOT file.                                                           //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDirectoryFile.h" 1
// @(#)root/io:$Id: TDirectoryFile.h 39611 2011-06-08 19:35:17Z pcanal $
// Author: Rene Brun   22/01/2007

/*************************************************************************
 * Copyright (C) 1995-2007, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TDirectoryFile                                                       //
//                                                                      //
// Describe directory structure in a ROOT file.                         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDirectory.h" 1
// @(#)root/base:$Id: TDirectory.h 41092 2011-10-03 07:30:06Z pcanal $
// Author: Rene Brun   28/11/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TDirectory                                                           //
//                                                                      //
// Describe directory structure in memory.                              //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNamed.h" 1
// @(#)root/base:$Id: TNamed.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TNamed                                                               //
//                                                                      //
// The basis for a named object (name, title).                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 33 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNamed.h"
class TNamed : public TObject {

protected:
   TString fName; //object identifier
   TString fTitle; //object title

public:
   TNamed(): fName(), fTitle() { }
   TNamed(const char *name, const char *title) : fName(name), fTitle(title) { }
   TNamed(const TString &name, const TString &title) : fName(name), fTitle(title) { }
   TNamed(const TNamed &named);
   TNamed& operator=(const TNamed& rhs);
   virtual ~TNamed() { }
   virtual void Clear(Option_t *option ="");
   virtual TObject *Clone(const char *newname="") const;
   virtual Int_t Compare(const TObject *obj) const;
   virtual void Copy(TObject &named) const;
   virtual void FillBuffer(char *&buffer);
   virtual const char *GetName() const { return fName; }
   virtual const char *GetTitle() const { return fTitle; }
   virtual ULong_t Hash() const { return fName.Hash(); }
   virtual Bool_t IsSortable() const { return kTRUE; }
   virtual void SetName(const char *name); // *MENU*
   virtual void SetNameTitle(const char *name, const char *title);
   virtual void SetTitle(const char *title=""); // *MENU*
   virtual void ls(Option_t *option="") const;
   virtual void Print(Option_t *option="") const;
   virtual Int_t Sizeof() const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TNamed::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TNamed::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNamed.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 62; } //The basis for a named object (name, title)
};
# 26 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDirectory.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TList.h" 1
// @(#)root/cont:$Id: TList.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Fons Rademakers   10/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TList                                                                //
//                                                                      //
// A doubly linked list. All classes inheriting from TObject can be     //
// inserted in a TList.                                                 //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSeqCollection.h" 1
// @(#)root/cont:$Id: TSeqCollection.h 38082 2011-02-16 00:52:04Z rdm $
// Author: Fons Rademakers   04/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TSeqCollection                                                       //
//                                                                      //
// Sequenceable collection abstract base class. TSeqCollection's have   //
// an ordering relation, i.e. there is a first and last element.        //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCollection.h" 1
// @(#)root/cont:$Id: TCollection.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Fons Rademakers   13/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TCollection                                                          //
//                                                                      //
// Collection abstract base class. This class inherits from TObject     //
// because we want to be able to have collections of collections.       //
//                                                                      //
//////////////////////////////////////////////////////////////////////////






# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TIterator.h" 1
// @(#)root/cont:$Id: TIterator.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Fons Rademakers   13/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TIterator                                                            //
//                                                                      //
// Iterator abstract base class. This base class provides the interface //
// for collection iterators.                                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TCollection;
class TObject;

class TIterator {

protected:
   TIterator() { }
   TIterator(const TIterator &) { }

public:
   virtual TIterator &operator=(const TIterator &) { return *this; }
   virtual ~TIterator() { }
   virtual const TCollection *GetCollection() const = 0;
   virtual Option_t *GetOption() const { return ""; }
   virtual TObject *Next() = 0;
   virtual void Reset() = 0;
   TObject *operator()() { return Next(); }
   virtual Bool_t operator!=(const TIterator &) const;
   virtual TObject *operator*() const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TIterator::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TIterator::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TIterator.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 49; } //Iterator abstract base class
};
# 31 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCollection.h" 2







class TClass;
class TObjectTable;
class TVirtualMutex;

const Bool_t kIterForward = kTRUE;
const Bool_t kIterBackward = !kIterForward;

extern TVirtualMutex *gCollectionMutex;

class TCollection : public TObject {

private:
   static TCollection *fgCurrentCollection; //used by macro R__FOR_EACH
   static TObjectTable *fgGarbageCollection; //used by garbage collector
   static Bool_t fgEmptyingGarbage; //used by garbage collector
   static Int_t fgGarbageStack; //used by garbage collector

   TCollection(const TCollection &); //private and not-implemented, collections
   void operator=(const TCollection &); //are too complex to be automatically copied

protected:
   enum { kIsOwner = (1ULL << (14)) };

   TString fName; //name of the collection
   Int_t fSize; //number of elements in collection

   TCollection() : fName(), fSize(0) { }

   virtual void PrintCollectionHeader(Option_t* option) const;
   virtual const char* GetCollectionEntryName(TObject* entry) const;
   virtual void PrintCollectionEntry(TObject* entry, Option_t* option, Int_t recurse) const;

public:
   enum { kInitCapacity = 16, kInitHashTableCapacity = 17 };

   virtual ~TCollection() { }
   virtual void Add(TObject *obj) = 0;
   void AddVector(TObject *obj1, ...);
   virtual void AddAll(const TCollection *col);
   Bool_t AssertClass(TClass *cl) const;
   void Browse(TBrowser *b);
   Int_t Capacity() const { return fSize; }
   virtual void Clear(Option_t *option="") = 0;
   virtual TObject *Clone(const char *newname="") const;
   Int_t Compare(const TObject *obj) const;
   Bool_t Contains(const char *name) const { return FindObject(name) != 0; }
   Bool_t Contains(const TObject *obj) const { return FindObject(obj) != 0; }
   virtual void Delete(Option_t *option="") = 0;
   virtual void Draw(Option_t *option="");
   virtual void Dump() const ;
   virtual TObject *FindObject(const char *name) const;
   TObject *operator()(const char *name) const;
   virtual TObject *FindObject(const TObject *obj) const;
   virtual Int_t GetEntries() const { return GetSize(); }
   virtual const char *GetName() const;
   virtual TObject **GetObjectRef(const TObject *obj) const = 0;
   virtual Int_t GetSize() const { return fSize; }
   virtual Int_t GrowBy(Int_t delta) const;
   ULong_t Hash() const { return fName.Hash(); }
   Bool_t IsArgNull(const char *where, const TObject *obj) const;
   virtual Bool_t IsEmpty() const { return GetSize() <= 0; }
   virtual Bool_t IsFolder() const { return kTRUE; }
   Bool_t IsOwner() const { return TestBit(kIsOwner); }
   Bool_t IsSortable() const { return kTRUE; }
   virtual void ls(Option_t *option="") const ;
   virtual TIterator *MakeIterator(Bool_t dir = kIterForward) const = 0;
   virtual TIterator *MakeReverseIterator() const { return MakeIterator(kIterBackward); }
   virtual void Paint(Option_t *option="");
   virtual void Print(Option_t *option="") const;
   virtual void Print(Option_t *option, Int_t recurse) const;
   virtual void Print(Option_t *option, const char* wildcard, Int_t recurse=1) const;
   virtual void Print(Option_t *option, TPRegexp& regexp, Int_t recurse=1) const;
   virtual void RecursiveRemove(TObject *obj);
   virtual TObject *Remove(TObject *obj) = 0;
   virtual void RemoveAll(TCollection *col);
   void RemoveAll() { Clear(); }
   void SetCurrentCollection();
   void SetName(const char *name) { fName = name; }
   virtual void SetOwner(Bool_t enable = kTRUE);
   virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0);
   virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0) const;

   static TCollection *GetCurrentCollection();
   static void StartGarbageCollection();
   static void GarbageCollect(TObject *obj);
   static void EmptyGarbageCollection();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TCollection::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TCollection::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCollection.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 125; } //Collection abstract base class
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TIter                                                                //
//                                                                      //
// Iterator wrapper. Type of iterator used depends on type of           //
// collection.                                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TIter {

private:
   TIterator *fIterator; //collection iterator

protected:
   TIter() : fIterator(0) { }

public:
   TIter(const TCollection *col, Bool_t dir = kIterForward)
         : fIterator(col ? col->MakeIterator(dir) : 0) { }
   TIter(TIterator *it) : fIterator(it) { }
   TIter(const TIter &iter);
   TIter &operator=(const TIter &rhs);
   virtual ~TIter() { { if (fIterator) { delete fIterator; fIterator = 0; } }; }
   TObject *operator()() { return Next(); }
   TObject *Next() { return fIterator ? fIterator->Next() : 0; }
   const TCollection *GetCollection() const { return fIterator ? fIterator->GetCollection() : 0; }
   Option_t *GetOption() const { return fIterator ? fIterator->GetOption() : ""; }
   void Reset() { if (fIterator) fIterator->Reset(); }
   TIter &operator++() { Next(); return *this; }
   Bool_t operator!=(const TIter &aIter) const { return ((*fIterator) != *(aIter.fIterator)); }
   TObject *operator*() const { return *(*fIterator); }
   TIter &Begin();
   static TIter End();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TIter::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TIter::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCollection.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 164; } //Iterator wrapper
};

template <class T>
class TIterCategory: public TIter, public std::iterator_traits<typename T::Iterator_t> {

public:
   TIterCategory(const TCollection *col, Bool_t dir = kIterForward) : TIter(col, dir) { }
   TIterCategory(TIterator *it) : TIter(it) { }
   virtual ~TIterCategory() { }
   TIterCategory &Begin() { TIter::Begin(); return *this; }
   static TIterCategory End() { return TIterCategory(static_cast<TIterator*>(0)); }
};


//---- R__FOR_EACH macro -------------------------------------------------------

// Macro to loop over all elements of a list of type "type" while executing
// procedure "proc" on each element
# 27 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSeqCollection.h" 2



class TSeqCollection : public TCollection {

protected:
   Bool_t fSorted; // true if collection has been sorted

   TSeqCollection() : fSorted(kFALSE) { }
   virtual void Changed() { fSorted = kFALSE; }

public:
   virtual ~TSeqCollection() { }
   virtual void Add(TObject *obj) { AddLast(obj); }
   virtual void AddFirst(TObject *obj) = 0;
   virtual void AddLast(TObject *obj) = 0;
   virtual void AddAt(TObject *obj, Int_t idx) = 0;
   virtual void AddAfter(const TObject *after, TObject *obj) = 0;
   virtual void AddBefore(const TObject *before, TObject *obj) = 0;
   virtual void RemoveFirst() { Remove(First()); }
   virtual void RemoveLast() { Remove(Last()); }
   virtual TObject *RemoveAt(Int_t idx) { return Remove(At(idx)); }
   virtual void RemoveAfter(TObject *after) { Remove(After(after)); }
   virtual void RemoveBefore(TObject *before) { Remove(Before(before)); }

   virtual TObject *At(Int_t idx) const = 0;
   virtual TObject *Before(const TObject *obj) const = 0;
   virtual TObject *After(const TObject *obj) const = 0;
   virtual TObject *First() const = 0;
   virtual TObject *Last() const = 0;
   Int_t LastIndex() const { return GetSize() - 1; }
   virtual Int_t GetLast() const;
   virtual Int_t IndexOf(const TObject *obj) const;
   virtual Bool_t IsSorted() const { return fSorted; }
   void UnSort() { fSorted = kFALSE; }
   Long64_t Merge(TCollection *list);

   static Int_t ObjCompare(TObject *a, TObject *b);
   static void QSort(TObject **a, Int_t first, Int_t last);
   static inline void QSort(TObject **a, TObject **b, Int_t first, Int_t last) { QSort(a, 1, &b, first, last); }
   static void QSort(TObject **a, Int_t nBs, TObject ***b, Int_t first, Int_t last);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TSeqCollection::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TSeqCollection::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSeqCollection.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 69; } //Sequenceable collection ABC
};
# 27 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TList.h" 2





# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <iterator.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/iterator

#pragma ifndef PREC_STL_ITERATOR
#pragma define PREC_STL_ITERATOR
#pragma link off global PREC_STL_ITERATOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from STL HP implementation 1994
// Imported from STL SGI implementation 1997 
// Imported from ANSI/ISO C++ draft Nov 1997
// Modified by Masaharu Goto
// May need improvement for the latest standard


////////////////////////////////////////////////////////////////////////
// iterator_tag
////////////////////////////////////////////////////////////////////////
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag {};
struct bidirectional_iterator_tag {};
struct random_access_iterator_tag {};

////////////////////////////////////////////////////////////////////////
// iterator template
////////////////////////////////////////////////////////////////////////
template <class T, class Distance> struct input_iterator {};
struct output_iterator {};
template <class T, class Distance> struct forward_iterator {};
template <class T, class Distance> struct bidirectional_iterator {};
template <class T, class Distance> struct random_access_iterator {};

#pragma link off class output_iterator;







////////////////////////////////////////////////////////////////////////
// iterator_category overloaded function
////////////////////////////////////////////////////////////////////////
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const input_iterator<T, Distance>&) {
    return input_iterator_tag();
}

inline output_iterator_tag iterator_category(const output_iterator&) {
    return output_iterator_tag();
}

#pragma link off function iterator_category(const output_iterator&);


template <class T, class Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<T, Distance>&) {
    return forward_iterator_tag();
}

template <class T, class Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<T, Distance>&) {
    return bidirectional_iterator_tag();
}

template <class T, class Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<T, Distance>&) {
    return random_access_iterator_tag();
}

template <class T>
inline random_access_iterator_tag
iterator_category(const T*) {
    return random_access_iterator_tag();
}


// iterator_traits, iterator and reverse_iterator template may not be
// needed for precompiled library interface 

////////////////////////////////////////////////////////////////////////
// iterator_traits
////////////////////////////////////////////////////////////////////////

template <class Iterator>
struct iterator_traits {
  typedef typename Iterator::iterator_category iterator_category;
  typedef typename Iterator::value_type value_type;
  typedef typename Iterator::difference_type difference_type;
  typedef typename Iterator::pointer pointer;
  typedef typename Iterator::reference reference;
};

// template partial specialization, implement in cint5.15.14 1587
template <class T>
struct iterator_traits<T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef T& reference;
};

// incomplete implementation in cint5.15.14 1587, need some fix
// iterator_traits<const int*> is changed as iterator_traits<const int* const>
// or something, but cint5.15.14 can not handle this well
template <class T>
struct iterator_traits<const T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef const T* pointer;
  typedef const T& reference;
};

////////////////////////////////////////////////////////////////////////
// iterator
////////////////////////////////////////////////////////////////////////
template<class Category, class T, class Distance = ptrdiff_t,
         class Pointer = T*, class Reference = T&>
struct iterator {
  typedef T value_type;
  typedef Distance difference_type;
  typedef Pointer pointer;
  typedef Reference reference;
  typedef Category iterator_category;
};


////////////////////////////////////////////////////////////////////////
// reverse_iterator
////////////////////////////////////////////////////////////////////////






template <class Iterator>
class reverse_iterator
# 166 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
{




 public:
# 181 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
   typedef Iterator::pointer pointer;
   typedef Iterator::reference reference;
   typedef ptrdiff_t difference_type;


   reverse_iterator();
   //reverse_iterator(Iterator x);



   Iterator base() const; // explicit
   reference operator*() const;
   pointer operator->() const;
   reverse_iterator& operator++();
   reverse_iterator operator++(int);
   reverse_iterator& operator--();
   reverse_iterator operator--(int);
   reverse_iterator operator+ (difference_type n) const;
   reverse_iterator& operator+=(difference_type n);
   reverse_iterator operator- (difference_type n) const;
   reverse_iterator& operator-=(difference_type n);
   reference operator[](difference_type n) const;
};
# 932 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
// for g++ 3.1,3.2
namespace __gnu_cxx
{
  // This iterator adapter is 'normal' in the sense that it does not
  // change the semantics of any of the operators of its iterator
  // parameter.  Its primary purpose is to convert an iterator that is
  // not a class, e.g. a pointer, into an iterator that is a class.
  // The _Container parameter exists solely so that different containers
  // using this template can instantiate different types, even if the
  // _Iterator parameter is the same.
  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
      : public iterator<typename iterator_traits<_Iterator>::iterator_category,
                        typename iterator_traits<_Iterator>::value_type,
                        typename iterator_traits<_Iterator>::difference_type,
                        typename iterator_traits<_Iterator>::pointer,
                        typename iterator_traits<_Iterator>::reference>
    {
    protected:
      _Iterator _M_current;

    public:
      typedef typename iterator_traits<_Iterator>::difference_type
                    difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

      __normal_iterator() : _M_current(_Iterator()) { }

      explicit
      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

      // Allow iterator to const_iterator conversion
      template<typename _Iter>
      inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
 : _M_current(__i.base()) { }

      // Forward iterator requirements
      reference
      operator*() const { return *_M_current; }

      pointer
      operator->() const { return _M_current; }

      __normal_iterator&
      operator++() { ++_M_current; return *this; }

      __normal_iterator
      operator++(int) { return __normal_iterator(_M_current++); }

      // Bidirectional iterator requirements
      __normal_iterator&
      operator--() { --_M_current; return *this; }

      __normal_iterator
      operator--(int) { return __normal_iterator(_M_current--); }

      // Random access iterator requirements
      reference
      operator[](const difference_type& __n) const
      { return _M_current[__n]; }

      __normal_iterator&
      operator+=(const difference_type& __n)
      { _M_current += __n; return *this; }

      __normal_iterator
      operator+(const difference_type& __n) const
      { return __normal_iterator(_M_current + __n); }

      __normal_iterator&
      operator-=(const difference_type& __n)
      { _M_current -= __n; return *this; }

      __normal_iterator
      operator-(const difference_type& __n) const
      { return __normal_iterator(_M_current - __n); }

      const _Iterator&
      base() const { return _M_current; }
    };

  // Note: In what follows, the left- and right-hand-side iterators are
  // allowed to vary in types (conceptually in cv-qualification) so that
  // comparaison between cv-qualified and non-cv-qualified iterators be
  // valid.  However, the greedy and unfriendly operators in std::rel_ops
  // will make overload resolution ambiguous (when in scope) if we don't
  // provide overloads whose operands are of the same type.  Can someone
  // remind me what generic programming is about? -- Gaby

  // Forward iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  // Random access iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  // _GLIBCPP_RESOLVE_LIB_DEFECTS
  // According to the resolution of DR179 not only the various comparison
  // operators but also operator- must accept mixed iterator/const_iterator
  // parameters.
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
     const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
} // namespace __gnu_cxx







#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 2
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/iterator" 2
}
# 33 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TList.h" 2


// Prevent -Weffc++ from complaining about the inheritance
// TListIter from std::iterator.
       
# 38 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TList.h" 3


const Bool_t kSortAscending = kTRUE;
const Bool_t kSortDescending = !kSortAscending;

class TObjLink;
class TListIter;


class TList : public TSeqCollection {

friend class TListIter;

protected:
   TObjLink *fFirst; //! pointer to first entry in linked list
   TObjLink *fLast; //! pointer to last entry in linked list
   TObjLink *fCache; //! cache to speedup sequential calling of Before() and After() functions
   Bool_t fAscending; //! sorting order (when calling Sort() or for TSortedList)

   TObjLink *LinkAt(Int_t idx) const;
   TObjLink *FindLink(const TObject *obj, Int_t &idx) const;
   TObjLink **DoSort(TObjLink **head, Int_t n);
   Bool_t LnkCompare(TObjLink *l1, TObjLink *l2);
   virtual TObjLink *NewLink(TObject *obj, TObjLink *prev = 0);
   virtual TObjLink *NewOptLink(TObject *obj, Option_t *opt, TObjLink *prev = 0);
   virtual void DeleteLink(TObjLink *lnk);

private:
   TList(const TList&); // not implemented
   TList& operator=(const TList&); // not implemented

public:
   typedef TListIter Iterator_t;

   TList() : fFirst(0), fLast(0), fCache(0), fAscending(kTRUE) { }
   TList(TObject *) : fFirst(0), fLast(0), fCache(0), fAscending(kTRUE) { } // for backward compatibility, don't use
   virtual ~TList();
   virtual void Clear(Option_t *option="");
   virtual void Delete(Option_t *option="");
   virtual TObject *FindObject(const char *name) const;
   virtual TObject *FindObject(const TObject *obj) const;
   virtual TIterator *MakeIterator(Bool_t dir = kIterForward) const;

   virtual void Add(TObject *obj) { AddLast(obj); }
   virtual void Add(TObject *obj, Option_t *opt) { AddLast(obj, opt); }
   virtual void AddFirst(TObject *obj);
   virtual void AddFirst(TObject *obj, Option_t *opt);
   virtual void AddLast(TObject *obj);
   virtual void AddLast(TObject *obj, Option_t *opt);
   virtual void AddAt(TObject *obj, Int_t idx);
   virtual void AddAfter(const TObject *after, TObject *obj);
   virtual void AddAfter(TObjLink *after, TObject *obj);
   virtual void AddBefore(const TObject *before, TObject *obj);
   virtual void AddBefore(TObjLink *before, TObject *obj);
   virtual TObject *Remove(TObject *obj);
   virtual TObject *Remove(TObjLink *lnk);
   virtual void RemoveLast();
   virtual void RecursiveRemove(TObject *obj);

   virtual TObject *At(Int_t idx) const;
   virtual TObject *After(const TObject *obj) const;
   virtual TObject *Before(const TObject *obj) const;
   virtual TObject *First() const;
   virtual TObjLink *FirstLink() const { return fFirst; }
   virtual TObject **GetObjectRef(const TObject *obj) const;
   virtual TObject *Last() const;
   virtual TObjLink *LastLink() const { return fLast; }

   virtual void Sort(Bool_t order = kSortAscending);
   Bool_t IsAscending() { return fAscending; }

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 5; } static void Dictionary(); virtual TClass *IsA() const { return TList::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TList::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TList.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 109; } //Doubly linked list
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TObjLink                                                             //
//                                                                      //
// Wrapper around a TObject so it can be stored in a TList.             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
class TObjLink {

friend class TList;

private:
   TObjLink *fNext;
   TObjLink *fPrev;
   TObject *fObject;

   TObjLink(const TObjLink&); // not implemented
   TObjLink& operator=(const TObjLink&); // not implemented

protected:
   TObjLink() : fNext(0), fPrev(0), fObject(0) { fNext = fPrev = this; }

public:
   TObjLink(TObject *obj) : fNext(0), fPrev(0), fObject(obj) { }
   TObjLink(TObject *obj, TObjLink *lnk);
   virtual ~TObjLink() { }

   TObject *GetObject() const { return fObject; }
   TObject **GetObjectRef() { return &fObject; }
   void SetObject(TObject *obj) { fObject = obj; }
   virtual Option_t *GetAddOption() const { return ""; }
   virtual Option_t *GetOption() const { return fObject->GetOption(); }
   virtual void SetOption(Option_t *) { }
   TObjLink *Next() { return fNext; }
   TObjLink *Prev() { return fPrev; }
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TObjOptLink                                                          //
//                                                                      //
// Wrapper around a TObject so it can be stored in a TList including    //
// an option string.                                                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
class TObjOptLink : public TObjLink {

private:
   TString fOption;

public:
   TObjOptLink(TObject *obj, Option_t *opt) : TObjLink(obj), fOption(opt) { }
   TObjOptLink(TObject *obj, TObjLink *lnk, Option_t *opt) : TObjLink(obj, lnk), fOption(opt) { }
   ~TObjOptLink() { }
   Option_t *GetAddOption() const { return fOption.Data(); }
   Option_t *GetOption() const { return fOption.Data(); }
   void SetOption(Option_t *option) { fOption = option; }
};


// Preventing warnings with -Weffc++ in GCC since it is a false positive for the TListIter destructor.





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TListIter                                                            //
//                                                                      //
// Iterator of linked list.                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
class TListIter : public TIterator,
                  public std::iterator<std::bidirectional_iterator_tag,
                                       TObject*, std::ptrdiff_t,
                                       const TObject**, const TObject*&> {

protected:
   const TList *fList; //list being iterated
   TObjLink *fCurCursor; //current position in list
   TObjLink *fCursor; //next position in list
   Bool_t fDirection; //iteration direction
   Bool_t fStarted; //iteration started

   TListIter() : fList(0), fCurCursor(0), fCursor(0), fDirection(kIterForward),
                 fStarted(kFALSE) { }

public:
   TListIter(const TList *l, Bool_t dir = kIterForward);
   TListIter(const TListIter &iter);
   ~TListIter() { }
   TIterator &operator=(const TIterator &rhs);
   TListIter &operator=(const TListIter &rhs);

   const TCollection *GetCollection() const { return fList; }
   Option_t *GetOption() const;
   void SetOption(Option_t *option);
   TObject *Next();
   void Reset();
   Bool_t operator!=(const TIterator &aIter) const;
   Bool_t operator!=(const TListIter &aIter) const;
   TObject *operator*() const { return (fCurCursor ? fCurCursor->GetObject() : 0); }

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TListIter::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TListIter::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TList.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 218; } //Linked list iterator
};
# 29 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDirectory.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDatime.h" 1
// @(#)root/base:$Id: TDatime.h 31064 2009-11-10 14:39:38Z rdm $
// Author: Rene Brun   05/01/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TDatime                                                              //
//                                                                      //
// This class stores the date and time with a precision of one second   //
// in an unsigned 32 bit word (e.g. 950130 124559). The date is stored  //
// with the origin being the 1st january 1995.                          //
//                                                                      //
// This class has no support for time zones. The time is assumed        //
// to be in the local time of the machine where the object was created. //
// As a result, TDatime objects are not portable between machines       //
// operating in different time zones and unsuitable for storing the     //
// date/time of data taking events and the like. If absolute time is    //
// required, use TTimeStamp.                                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////






class TDatime {

private:

protected:
   UInt_t fDatime; //Date (relative to 1995) + time

public:
   TDatime();
   TDatime(const TDatime &d): fDatime(d.fDatime) { }
   TDatime(UInt_t tloc, Bool_t dosDate = kFALSE): fDatime(0)
     { Set(tloc, dosDate); }
   TDatime(Int_t date, Int_t time);
   TDatime(Int_t year, Int_t month, Int_t day,
           Int_t hour, Int_t min, Int_t sec);
   TDatime(const char *sqlDateTime);
   virtual ~TDatime() { }

   TDatime& operator=(const TDatime &d);

   const char *AsString() const;
   const char *AsString(char *out) const;
   const char *AsSQLString() const;
   UInt_t Convert(Bool_t toGMT = kFALSE) const;
   void Copy(TDatime &datime) const;
   UInt_t Get() const;
   Int_t GetDate() const;
   Int_t GetTime() const;
   Int_t GetYear() const { return (fDatime>>26) + 1995; }
   Int_t GetMonth() const { return (fDatime<<6)>>28; }
   Int_t GetDay() const { return (fDatime<<10)>>27; }
   Int_t GetDayOfWeek() const;
   Int_t GetHour() const { return (fDatime<<15)>>27; }
   Int_t GetMinute() const { return (fDatime<<20)>>26; }
   Int_t GetSecond() const { return (fDatime<<26)>>26; }
   void FillBuffer(char *&buffer);
   void Print(Option_t *option="") const;
   void ReadBuffer(char *&buffer);
   void Set();
   void Set(UInt_t tloc, Bool_t dosDate = kFALSE);
   void Set(Int_t date, Int_t time);
   void Set(Int_t year, Int_t month, Int_t day,
                    Int_t hour, Int_t min, Int_t sec);
   void Set(const char *sqlDateTime);
   Int_t Sizeof() const {return sizeof(UInt_t);}

   friend Bool_t operator==(const TDatime &d1, const TDatime &d2);
   friend Bool_t operator!=(const TDatime &d1, const TDatime &d2);
   friend Bool_t operator< (const TDatime &d1, const TDatime &d2);
   friend Bool_t operator<=(const TDatime &d1, const TDatime &d2);
   friend Bool_t operator> (const TDatime &d1, const TDatime &d2);
   friend Bool_t operator>=(const TDatime &d1, const TDatime &d2);

   static void GetDateTime(UInt_t datetime, Int_t &date, Int_t &time);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TDatime::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TDatime::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDatime.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 93; } //Date and time 950130 124559
};


inline TDatime& TDatime::operator=(const TDatime &d)
   { fDatime = d.fDatime; return *this; }

inline Bool_t operator==(const TDatime &d1, const TDatime &d2)
   { return d1.fDatime == d2.fDatime; }
inline Bool_t operator!=(const TDatime &d1, const TDatime &d2)
   { return d1.fDatime != d2.fDatime; }
inline Bool_t operator< (const TDatime &d1, const TDatime &d2)
   { return d1.fDatime < d2.fDatime; }
inline Bool_t operator<=(const TDatime &d1, const TDatime &d2)
   { return d1.fDatime <= d2.fDatime; }
inline Bool_t operator> (const TDatime &d1, const TDatime &d2)
   { return d1.fDatime > d2.fDatime; }
inline Bool_t operator>=(const TDatime &d1, const TDatime &d2)
   { return d1.fDatime >= d2.fDatime; }
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDirectory.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TUUID.h" 1
// @(#)root/base:$Id: TUUID.h 27658 2009-02-28 05:34:57Z pcanal $
// Author: Fons Rademakers   30/9/2001

/*************************************************************************
 * Copyright (C) 1995-2001, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TUUID                                                                //
//                                                                      //
// This class defines a UUID (Universally Unique IDentifier), also      //
// known as GUIDs (Globally Unique IDentifier). A UUID is 128 bits      //
// long, and if generated according to this algorithm, is either        //
// guaranteed to be different from all other UUIDs/GUIDs generated      //
// until 3400 A.D. or extremely likely to be different. UUIDs were      //
// originally used in the Network Computing System (NCS) and            //
// later in the Open Software Foundation's (OSF) Distributed Computing  //
// Environment (DCE).                                                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 37 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TUUID.h"
// forward declaration
class TBuffer;
class TFile;
class TDirectory;
class TInetAddress;
class TDatime;

class TUUID {

protected:
   UInt_t fUUIDIndex; //!index in the list of UUIDs in TProcessUUID
   UInt_t fTimeLow; // 60 bit time, lower 32 bits
   UShort_t fTimeMid; // middle 16 time bits
   UShort_t fTimeHiAndVersion; // high 12 time bits + 4 UUID version bits
   UChar_t fClockSeqHiAndReserved; // high 6 clock bits + 2 bits reserved
   UChar_t fClockSeqLow; // low 8 clock bits
   UChar_t fNode[6]; // 6 node id bytes

   struct uuid_time_t {
      UInt_t high;
      UInt_t low;
   };

   Int_t CmpTime(uuid_time_t *t1, uuid_time_t *t2);
   void Format(UShort_t clockseq, uuid_time_t ts);
   void GetNodeIdentifier();
   void GetCurrentTime(uuid_time_t *timestamp);
   void GetSystemTime(uuid_time_t *timestamp);
   void GetRandomInfo(UChar_t seed[16]);
   void SetFromString(const char *uuid_str);

public:
   TUUID();
   TUUID(const char *uuid_str);
   virtual ~TUUID();

   const char *AsString() const;
   Int_t Compare(const TUUID &u) const;
   UShort_t Hash() const;
   void Print() const;
   TInetAddress GetHostAddress() const;
   TDatime GetTime() const;
   void GetUUID(UChar_t uuid[16]) const;
   void SetUUID(const char *uuid_str);
   UInt_t GetUUIDNumber() const { return fUUIDIndex; }
   void SetUUIDNumber(UInt_t index) { fUUIDIndex = index; }

   void StreamerV1(TBuffer &b);
   void FillBuffer(char *&buffer);
   void ReadBuffer(char *&buffer);
   Int_t Sizeof() const { return 18; }

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TUUID::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TUUID::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TUUID.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 89; } // Universally Unique IDentifier
};


inline TBuffer &operator>>(TBuffer &buf, TUUID &uuid)
{ uuid.Streamer(buf); return buf; }

// Not inlined in order to avoid const casted away warning in user code.  
TBuffer &operator<<(TBuffer &buf, const TUUID &uuid);

inline Bool_t operator==(const TUUID &u1, const TUUID &u2)
{ return (!u1.Compare(u2)) ? kTRUE : kFALSE; }

inline Bool_t operator!=(const TUUID &u1, const TUUID &u2)
{ return !(u1 == u2); }
# 35 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDirectory.h" 2


class TBrowser;
class TKey;
class TFile;

class TDirectory : public TNamed {
public:
   /** @class Context
     *
     *  Small helper to keep current directory context.
     *  Automatically reverts to "old" directory
     */
   class TContext {
   private:
      TDirectory *fDirectory; //! Pointer to the previous current directory.
      TContext *fPrevious; //! Pointer to the next TContext in the implied list of context pointing to fPrevious.
      TContext *fNext; //! Pointer to the next TContext in the implied list of context pointing to fPrevious.
      TContext(TContext&);
      TContext& operator=(TContext&);
      void CdNull();
      friend class TDirectory;
   public:
      TContext(TDirectory* previous, TDirectory* newCurrent)
         : fDirectory(previous),fPrevious(0),fNext(0)
      {
         // Store the current directory so we can restore it
         // later and cd to the new directory.
         if ( fDirectory ) fDirectory->RegisterContext(this);
         if ( newCurrent ) newCurrent->cd();
      }
      TContext(TDirectory* newCurrent) : fDirectory(TDirectory::CurrentDirectory()),fPrevious(0),fNext(0)
      {
         // Store the current directory so we can restore it
         // later and cd to the new directory.
         if ( fDirectory ) fDirectory->RegisterContext(this);
         if ( newCurrent ) newCurrent->cd();
      }
      ~TContext()
      {
         // Destructor.   Reset the current directory to its
         // previous state.
         if ( fDirectory ) {
            fDirectory->UnregisterContext(this);
            fDirectory->cd();
         }
         else CdNull();
      }
   };

protected:

   TObject *fMother; //pointer to mother of the directory
   TList *fList; //List of objects in memory
   TUUID fUUID; //Unique identifier
   TString fPathBuffer; //!Buffer for GetPath() function
   TContext *fContext; //!Pointer to a list of TContext object pointing to this TDirectory
   static Bool_t fgAddDirectory; //!flag to add histograms, graphs,etc to the directory

          Bool_t cd1(const char *path);
   static Bool_t Cd1(const char *path);

   virtual void CleanTargets();
           void FillFullPath(TString& buf) const;
           void RegisterContext(TContext *ctxt);
           void UnregisterContext(TContext *ctxt);
   friend class TContext;

protected:
   TDirectory(const TDirectory &directory); //Directories cannot be copied
   void operator=(const TDirectory &); //Directorise cannot be copied

public:

   TDirectory();
   TDirectory(const char *name, const char *title, Option_t *option="", TDirectory* motherDir = 0);
   virtual ~TDirectory();
   static void AddDirectory(Bool_t add=kTRUE);
   static Bool_t AddDirectoryStatus();
   virtual void Append(TObject *obj, Bool_t replace = kFALSE);
   virtual void Add(TObject *obj, Bool_t replace = kFALSE) { Append(obj,replace); }
   virtual Int_t AppendKey(TKey *) {return 0;}
   virtual void Browse(TBrowser *b);
   virtual void Build(TFile* motherFile = 0, TDirectory* motherDir = 0);
   virtual void Clear(Option_t *option="");
   virtual TObject *CloneObject(const TObject *obj, Bool_t autoadd = kTRUE);
   virtual void Close(Option_t *option="");
   static TDirectory *&CurrentDirectory(); // Return the current directory for this thread.   
   virtual void Copy(TObject &) const { MayNotUse("Copy(TObject &)"); }
   virtual Bool_t cd(const char *path = 0);
   virtual void DeleteAll(Option_t *option="");
   virtual void Delete(const char *namecycle="");
   virtual void Draw(Option_t *option="");
   virtual TKey *FindKey(const char * /*keyname*/) const {return 0;}
   virtual TKey *FindKeyAny(const char * /*keyname*/) const {return 0;}
   virtual TObject *FindObject(const char *name) const;
   virtual TObject *FindObject(const TObject *obj) const;
   virtual TObject *FindObjectAny(const char *name) const;
   virtual TObject *FindObjectAnyFile(const char * /*name*/) const {return 0;}
   virtual TObject *Get(const char *namecycle);
   virtual TDirectory *GetDirectory(const char *namecycle, Bool_t printError = false, const char *funcname = "GetDirectory");
   template <class T> inline void GetObject(const char* namecycle, T*& ptr) // See TDirectory::Get for information
      {
         ptr = (T*)GetObjectChecked(namecycle,TBuffer::GetClass(typeid(T)));
      }
   virtual void *GetObjectChecked(const char *namecycle, const char* classname);
   virtual void *GetObjectChecked(const char *namecycle, const TClass* cl);
   virtual void *GetObjectUnchecked(const char *namecycle);
   virtual Int_t GetBufferSize() const {return 0;}
   virtual TFile *GetFile() const { return 0; }
   virtual TKey *GetKey(const char * /*name */, Short_t /* cycle */=9999) const {return 0;}
   virtual TList *GetList() const { return fList; }
   virtual TList *GetListOfKeys() const { return 0; }
   virtual TObject *GetMother() const { return fMother; }
   virtual TDirectory *GetMotherDir() const { return fMother==0 ? 0 : dynamic_cast<TDirectory*>(fMother); }
   virtual Int_t GetNbytesKeys() const { return 0; }
   virtual Int_t GetNkeys() const { return 0; }
   virtual Long64_t GetSeekDir() const { return 0; }
   virtual Long64_t GetSeekParent() const { return 0; }
   virtual Long64_t GetSeekKeys() const { return 0; }
   virtual const char *GetPathStatic() const;
   virtual const char *GetPath() const;
   TUUID GetUUID() const {return fUUID;}
   virtual Bool_t IsFolder() const { return kTRUE; }
   virtual Bool_t IsModified() const { return kFALSE; }
   virtual Bool_t IsWritable() const { return kFALSE; }
   virtual void ls(Option_t *option="") const;
   virtual TDirectory *mkdir(const char *name, const char *title="");
   virtual TFile *OpenFile(const char * /*name*/, Option_t * /*option*/ = "",
                            const char * /*ftitle*/ = "", Int_t /*compress*/ = 1,
                            Int_t /*netopt*/ = 0) {return 0;}
   virtual void Paint(Option_t *option="");
   virtual void Print(Option_t *option="") const;
   virtual void Purge(Short_t /*nkeep*/=1) {}
   virtual void pwd() const;
   virtual void ReadAll(Option_t * /*option*/="") {}
   virtual Int_t ReadKeys(Bool_t /*forceRead*/=kTRUE) {return 0;}
   virtual Int_t ReadTObject(TObject * /*obj*/, const char * /*keyname*/) {return 0;}
   virtual TObject *Remove(TObject*);
   virtual void RecursiveRemove(TObject *obj);
   virtual void rmdir(const char *name);
   virtual void Save() {}
   virtual Int_t SaveObjectAs(const TObject * /*obj*/, const char * /*filename*/="", Option_t * /*option*/="") const;
   virtual void SaveSelf(Bool_t /*force*/ = kFALSE) {}
   virtual void SetBufferSize(Int_t /* bufsize */) {}
   virtual void SetModified() {}
   virtual void SetMother(TObject *mother) {fMother = (TObject*)mother;}
   virtual void SetName(const char* newname);
   virtual void SetTRefAction(TObject * /*ref*/, TObject * /*parent*/) {}
   virtual void SetSeekDir(Long64_t) {}
   virtual void SetWritable(Bool_t) {}
   virtual Int_t Sizeof() const {return 0;}
   virtual Int_t Write(const char * /*name*/=0, Int_t /*opt*/=0, Int_t /*bufsize*/=0){return 0;}
   virtual Int_t Write(const char * /*name*/=0, Int_t /*opt*/=0, Int_t /*bufsize*/=0) const {return 0;}
   virtual Int_t WriteTObject(const TObject *obj, const char *name =0, Option_t * /*option*/="", Int_t /*bufsize*/ =0);
   template <class T> inline Int_t WriteObject(const T* obj, const char* name, Option_t *option="", Int_t bufsize=0) // see TDirectory::WriteTObject or TDirectoryWriteObjectAny for explanation
      {
         return WriteObjectAny(obj,TBuffer::GetClass(typeid(T)),name,option,bufsize);
      }
   virtual Int_t WriteObjectAny(const void *, const char * /*classname*/, const char * /*name*/, Option_t * /*option*/="", Int_t /*bufsize*/ =0) {return 0;}
   virtual Int_t WriteObjectAny(const void *, const TClass * /*cl*/, const char * /*name*/, Option_t * /*option*/="", Int_t /*bufsize*/ =0) {return 0;}
   virtual void WriteDirHeader() {}
   virtual void WriteKeys() {}

   static Bool_t Cd(const char *path);
   static void DecodeNameCycle(const char *namecycle, char *name, Short_t &cycle);
   static void EncodeNameCycle(char *buffer, const char *name, Short_t cycle);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 5; } static void Dictionary(); virtual TClass *IsA() const { return TDirectory::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TDirectory::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDirectory.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 203; } //Describe directory structure in memory
};





// To properly handle the use of gDirectory in header files (in static declarations)
extern TDirectory *gDirectory;
# 26 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDirectoryFile.h" 2


class TList;
class TBrowser;
class TKey;
class TFile;

class TDirectoryFile : public TDirectory {

protected:
   Bool_t fModified; //true if directory has been modified
   Bool_t fWritable; //true if directory is writable
   TDatime fDatimeC; //Date and time when directory is created
   TDatime fDatimeM; //Date and time of last modification
   Int_t fNbytesKeys; //Number of bytes for the keys
   Int_t fNbytesName; //Number of bytes in TNamed at creation time
   Int_t fBufferSize; //Default buffer size to create new TKeys
   Long64_t fSeekDir; //Location of directory on file
   Long64_t fSeekParent; //Location of parent directory on file
   Long64_t fSeekKeys; //Location of Keys record on file
   TFile *fFile; //pointer to current file in memory
   TList *fKeys; //Pointer to keys list in memory

   virtual void CleanTargets();
   void Init(TClass *cl = 0);

private:
   TDirectoryFile(const TDirectoryFile &directory); //Directories cannot be copied
   void operator=(const TDirectoryFile &); //Directories cannot be copied

public:
   // TDirectory status bits
   enum { kCloseDirectory = (1ULL << (7)) };

   TDirectoryFile();
   TDirectoryFile(const char *name, const char *title, Option_t *option="", TDirectory* motherDir = 0);
   virtual ~TDirectoryFile();
   virtual void Append(TObject *obj, Bool_t replace = kFALSE);
           void Add(TObject *obj, Bool_t replace = kFALSE) { Append(obj,replace); }
           Int_t AppendKey(TKey *key);
   virtual void Browse(TBrowser *b);
           void Build(TFile* motherFile = 0, TDirectory* motherDir = 0);
   virtual TObject *CloneObject(const TObject *obj, Bool_t autoadd = kTRUE);
   virtual void Close(Option_t *option="");
   virtual void Copy(TObject &) const { MayNotUse("Copy(TObject &)"); }
   virtual Bool_t cd(const char *path = 0);
   virtual void Delete(const char *namecycle="");
   virtual void FillBuffer(char *&buffer);
   virtual TKey *FindKey(const char *keyname) const;
   virtual TKey *FindKeyAny(const char *keyname) const;
   virtual TObject *FindObjectAny(const char *name) const;
   virtual TObject *FindObjectAnyFile(const char *name) const;
   virtual TObject *Get(const char *namecycle);
   virtual TDirectory *GetDirectory(const char *apath, Bool_t printError = false, const char *funcname = "GetDirectory");
   template <class T> inline void GetObject(const char* namecycle, T*& ptr) // See TDirectory::Get for information
      {
         ptr = (T*)GetObjectChecked(namecycle,TBuffer::GetClass(typeid(T)));
      }
   virtual void *GetObjectChecked(const char *namecycle, const char* classname);
   virtual void *GetObjectChecked(const char *namecycle, const TClass* cl);
   virtual void *GetObjectUnchecked(const char *namecycle);
   virtual Int_t GetBufferSize() const;
   const TDatime &GetCreationDate() const { return fDatimeC; }
   virtual TFile *GetFile() const { return fFile; }
   virtual TKey *GetKey(const char *name, Short_t cycle=9999) const;
   virtual TList *GetListOfKeys() const { return fKeys; }
   const TDatime &GetModificationDate() const { return fDatimeM; }
   virtual Int_t GetNbytesKeys() const { return fNbytesKeys; }
   virtual Int_t GetNkeys() const { return fKeys->GetSize(); }
   virtual Long64_t GetSeekDir() const { return fSeekDir; }
   virtual Long64_t GetSeekParent() const { return fSeekParent; }
   virtual Long64_t GetSeekKeys() const { return fSeekKeys; }
   Bool_t IsModified() const { return fModified; }
   Bool_t IsWritable() const { return fWritable; }
   virtual void ls(Option_t *option="") const;
   virtual TDirectory *mkdir(const char *name, const char *title="");
   virtual TFile *OpenFile(const char *name, Option_t *option= "",
                            const char *ftitle = "", Int_t compress = 1,
                            Int_t netopt = 0);
   virtual void Purge(Short_t nkeep=1);
   virtual void ReadAll(Option_t *option="");
   virtual Int_t ReadKeys(Bool_t forceRead=kTRUE);
   virtual Int_t ReadTObject(TObject *obj, const char *keyname);
   virtual void ResetAfterMerge(TFileMergeInfo *);
   virtual void rmdir(const char *name);
   virtual void Save();
   virtual void SaveSelf(Bool_t force = kFALSE);
   virtual Int_t SaveObjectAs(const TObject *obj, const char *filename="", Option_t *option="") const;
   virtual void SetBufferSize(Int_t bufsize);
   void SetModified() {fModified = kTRUE;}
   void SetSeekDir(Long64_t v) { fSeekDir = v; }
   virtual void SetTRefAction(TObject *ref, TObject *parent);
   void SetWritable(Bool_t writable=kTRUE);
   virtual Int_t Sizeof() const;
   virtual Int_t Write(const char *name=0, Int_t opt=0, Int_t bufsize=0);
   virtual Int_t Write(const char *name=0, Int_t opt=0, Int_t bufsize=0) const ;
   virtual Int_t WriteTObject(const TObject *obj, const char *name=0, Option_t *option="", Int_t bufsize=0);
   virtual Int_t WriteObjectAny(const void *obj, const char *classname, const char *name, Option_t *option="", Int_t bufsize=0);
   virtual Int_t WriteObjectAny(const void *obj, const TClass *cl, const char *name, Option_t *option="", Int_t bufsize=0);
   virtual void WriteDirHeader();
   virtual void WriteKeys();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 5; } static void Dictionary(); virtual TClass *IsA() const { return TDirectoryFile::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TDirectoryFile::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDirectoryFile.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 128; } //Describe directory structure in a ROOT file
};
# 26 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFile.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMap.h" 1
// @(#)root/cont:$Id: TMap.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Fons Rademakers   12/11/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMap                                                                 //
//                                                                      //
// TMap implements an associative array of (key,value) pairs using a    //
// hash table for efficient retrieval (therefore TMap does not conserve //
// the order of the entries). The hash value is calculated              //
// using the value returned by the keys Hash() function. Both key and   //
// value need to inherit from TObject.                                  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/THashTable.h" 1
// @(#)root/cont:$Id: THashTable.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Fons Rademakers   27/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// THashTable                                                           //
//                                                                      //
// THashTable implements a hash table to store TObject's. The hash      //
// value is calculated using the value returned by the TObject's        //
// Hash() function. Each class inheriting from TObject can override     //
// Hash() as it sees fit.                                               //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 34 "/nfs/RAID/opt/root/v5.34.01_sl61/include/THashTable.h"
class TList;
class TListIter;
class THashTableIter;


class THashTable : public TCollection {

friend class THashTableIter;

private:
   TList **fCont; //Hash table (table of lists)
   Int_t fEntries; //Number of objects in table
   Int_t fUsedSlots; //Number of used slots
   Int_t fRehashLevel; //Average collision rate which triggers rehash

   Int_t GetHashValue(const TObject *obj) const;
   Int_t GetHashValue(TString &s) const { return s.Hash() % fSize; }
   Int_t GetHashValue(const char *str) const { return ::Hash(str) % fSize; }

   THashTable(const THashTable&); // not implemented
   THashTable& operator=(const THashTable&); // not implemented

public:
   THashTable(Int_t capacity = TCollection::kInitHashTableCapacity, Int_t rehash = 0);
   virtual ~THashTable();
   void Add(TObject *obj);
   virtual void AddAll(const TCollection *col);
   Float_t AverageCollisions() const;
   void Clear(Option_t *option="");
   Int_t Collisions(const char *name) const;
   Int_t Collisions(TObject *obj) const;
   void Delete(Option_t *option="");
   TObject *FindObject(const char *name) const;
   TObject *FindObject(const TObject *obj) const;
   TList *GetListForObject(const char *name) const;
   TList *GetListForObject(const TObject *obj) const;
   TObject **GetObjectRef(const TObject *obj) const;
   Int_t GetRehashLevel() const { return fRehashLevel; }
   Int_t GetSize() const { return fEntries; }
   TIterator *MakeIterator(Bool_t dir = kIterForward) const;
   void Rehash(Int_t newCapacity, Bool_t checkObjValidity = kTRUE);
   TObject *Remove(TObject *obj);
   TObject *RemoveSlow(TObject *obj);
   void SetRehashLevel(Int_t rehash) { fRehashLevel = rehash; }

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return THashTable::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { THashTable::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/THashTable.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 79; } //A hash table
};

inline Float_t THashTable::AverageCollisions() const
{
   if (fUsedSlots)
      return ((Float_t)fEntries)/fUsedSlots;
   else
      return 0.0;
}

inline Int_t THashTable::GetHashValue(const TObject *obj) const
{
   Int_t i = Int_t(obj->Hash() % fSize); // need intermediary i for Linux g++
   return i;
}


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// THashTableIter                                                       //
//                                                                      //
// Iterator of hash table.                                              //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class THashTableIter : public TIterator {

private:
   const THashTable *fTable; //hash table being iterated
   Int_t fCursor; //current position in table
   TListIter *fListCursor; //current position in collision list
   Bool_t fDirection; //iteration direction

   THashTableIter() : fTable(0), fCursor(0), fListCursor(0), fDirection(kIterForward) { }
   Int_t NextSlot();

public:
   THashTableIter(const THashTable *ht, Bool_t dir = kIterForward);
   THashTableIter(const THashTableIter &iter);
   ~THashTableIter();
   TIterator &operator=(const TIterator &rhs);
   THashTableIter &operator=(const THashTableIter &rhs);

   const TCollection *GetCollection() const { return fTable; }
   TObject *Next();
   void Reset();
   Bool_t operator!=(const TIterator &aIter) const;
   Bool_t operator!=(const THashTableIter &aIter) const;
   TObject *operator*() const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return THashTableIter::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { THashTableIter::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/THashTable.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 130; } //Hash table iterator
};
# 33 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMap.h" 2


# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <iterator.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/iterator

#pragma ifndef PREC_STL_ITERATOR
#pragma define PREC_STL_ITERATOR
#pragma link off global PREC_STL_ITERATOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from STL HP implementation 1994
// Imported from STL SGI implementation 1997 
// Imported from ANSI/ISO C++ draft Nov 1997
// Modified by Masaharu Goto
// May need improvement for the latest standard


////////////////////////////////////////////////////////////////////////
// iterator_tag
////////////////////////////////////////////////////////////////////////
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag {};
struct bidirectional_iterator_tag {};
struct random_access_iterator_tag {};

////////////////////////////////////////////////////////////////////////
// iterator template
////////////////////////////////////////////////////////////////////////
template <class T, class Distance> struct input_iterator {};
struct output_iterator {};
template <class T, class Distance> struct forward_iterator {};
template <class T, class Distance> struct bidirectional_iterator {};
template <class T, class Distance> struct random_access_iterator {};

#pragma link off class output_iterator;







////////////////////////////////////////////////////////////////////////
// iterator_category overloaded function
////////////////////////////////////////////////////////////////////////
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const input_iterator<T, Distance>&) {
    return input_iterator_tag();
}

inline output_iterator_tag iterator_category(const output_iterator&) {
    return output_iterator_tag();
}

#pragma link off function iterator_category(const output_iterator&);


template <class T, class Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<T, Distance>&) {
    return forward_iterator_tag();
}

template <class T, class Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<T, Distance>&) {
    return bidirectional_iterator_tag();
}

template <class T, class Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<T, Distance>&) {
    return random_access_iterator_tag();
}

template <class T>
inline random_access_iterator_tag
iterator_category(const T*) {
    return random_access_iterator_tag();
}


// iterator_traits, iterator and reverse_iterator template may not be
// needed for precompiled library interface 

////////////////////////////////////////////////////////////////////////
// iterator_traits
////////////////////////////////////////////////////////////////////////

template <class Iterator>
struct iterator_traits {
  typedef typename Iterator::iterator_category iterator_category;
  typedef typename Iterator::value_type value_type;
  typedef typename Iterator::difference_type difference_type;
  typedef typename Iterator::pointer pointer;
  typedef typename Iterator::reference reference;
};

// template partial specialization, implement in cint5.15.14 1587
template <class T>
struct iterator_traits<T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef T& reference;
};

// incomplete implementation in cint5.15.14 1587, need some fix
// iterator_traits<const int*> is changed as iterator_traits<const int* const>
// or something, but cint5.15.14 can not handle this well
template <class T>
struct iterator_traits<const T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef const T* pointer;
  typedef const T& reference;
};

////////////////////////////////////////////////////////////////////////
// iterator
////////////////////////////////////////////////////////////////////////
template<class Category, class T, class Distance = ptrdiff_t,
         class Pointer = T*, class Reference = T&>
struct iterator {
  typedef T value_type;
  typedef Distance difference_type;
  typedef Pointer pointer;
  typedef Reference reference;
  typedef Category iterator_category;
};


////////////////////////////////////////////////////////////////////////
// reverse_iterator
////////////////////////////////////////////////////////////////////////






template <class Iterator>
class reverse_iterator
# 166 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
{




 public:
# 181 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
   typedef Iterator::pointer pointer;
   typedef Iterator::reference reference;
   typedef ptrdiff_t difference_type;


   reverse_iterator();
   //reverse_iterator(Iterator x);



   Iterator base() const; // explicit
   reference operator*() const;
   pointer operator->() const;
   reverse_iterator& operator++();
   reverse_iterator operator++(int);
   reverse_iterator& operator--();
   reverse_iterator operator--(int);
   reverse_iterator operator+ (difference_type n) const;
   reverse_iterator& operator+=(difference_type n);
   reverse_iterator operator- (difference_type n) const;
   reverse_iterator& operator-=(difference_type n);
   reference operator[](difference_type n) const;
};
# 932 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
// for g++ 3.1,3.2
namespace __gnu_cxx
{
  // This iterator adapter is 'normal' in the sense that it does not
  // change the semantics of any of the operators of its iterator
  // parameter.  Its primary purpose is to convert an iterator that is
  // not a class, e.g. a pointer, into an iterator that is a class.
  // The _Container parameter exists solely so that different containers
  // using this template can instantiate different types, even if the
  // _Iterator parameter is the same.
  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
      : public iterator<typename iterator_traits<_Iterator>::iterator_category,
                        typename iterator_traits<_Iterator>::value_type,
                        typename iterator_traits<_Iterator>::difference_type,
                        typename iterator_traits<_Iterator>::pointer,
                        typename iterator_traits<_Iterator>::reference>
    {
    protected:
      _Iterator _M_current;

    public:
      typedef typename iterator_traits<_Iterator>::difference_type
                    difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

      __normal_iterator() : _M_current(_Iterator()) { }

      explicit
      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

      // Allow iterator to const_iterator conversion
      template<typename _Iter>
      inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
 : _M_current(__i.base()) { }

      // Forward iterator requirements
      reference
      operator*() const { return *_M_current; }

      pointer
      operator->() const { return _M_current; }

      __normal_iterator&
      operator++() { ++_M_current; return *this; }

      __normal_iterator
      operator++(int) { return __normal_iterator(_M_current++); }

      // Bidirectional iterator requirements
      __normal_iterator&
      operator--() { --_M_current; return *this; }

      __normal_iterator
      operator--(int) { return __normal_iterator(_M_current--); }

      // Random access iterator requirements
      reference
      operator[](const difference_type& __n) const
      { return _M_current[__n]; }

      __normal_iterator&
      operator+=(const difference_type& __n)
      { _M_current += __n; return *this; }

      __normal_iterator
      operator+(const difference_type& __n) const
      { return __normal_iterator(_M_current + __n); }

      __normal_iterator&
      operator-=(const difference_type& __n)
      { _M_current -= __n; return *this; }

      __normal_iterator
      operator-(const difference_type& __n) const
      { return __normal_iterator(_M_current - __n); }

      const _Iterator&
      base() const { return _M_current; }
    };

  // Note: In what follows, the left- and right-hand-side iterators are
  // allowed to vary in types (conceptually in cv-qualification) so that
  // comparaison between cv-qualified and non-cv-qualified iterators be
  // valid.  However, the greedy and unfriendly operators in std::rel_ops
  // will make overload resolution ambiguous (when in scope) if we don't
  // provide overloads whose operands are of the same type.  Can someone
  // remind me what generic programming is about? -- Gaby

  // Forward iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  // Random access iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  // _GLIBCPP_RESOLVE_LIB_DEFECTS
  // According to the resolution of DR179 not only the various comparison
  // operators but also operator- must accept mixed iterator/const_iterator
  // parameters.
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
     const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
} // namespace __gnu_cxx







#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 2
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/iterator" 2
}
# 36 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMap.h" 2


class THashTableIter;
class TMapIter;
class TPair;
class TBrowser;


class TMap : public TCollection {

friend class TMapIter;

private:
   THashTable *fTable; //Hash table used to store TPair's

   TMap(const TMap& map); // not implemented
   TMap& operator=(const TMap& map); // not implemented

protected:
   enum { kIsOwnerValue = (1ULL << (15)) };

   virtual void PrintCollectionEntry(TObject* entry, Option_t* option, Int_t recurse) const;

public:
   typedef TMapIter Iterator_t;

   TMap(Int_t capacity = TCollection::kInitHashTableCapacity, Int_t rehash = 0);
   virtual ~TMap();
   void Add(TObject *obj);
   void Add(TObject *key, TObject *value);
   Float_t AverageCollisions() const;
   Int_t Capacity() const;
   void Clear(Option_t *option="");
   Int_t Collisions(const char *keyname) const;
   Int_t Collisions(TObject *key) const;
   void Delete(Option_t *option="");
   void DeleteKeys() { Delete(); }
   void DeleteValues();
   void DeleteAll();
   Bool_t DeleteEntry(TObject *key);
   TObject *FindObject(const char *keyname) const;
   TObject *FindObject(const TObject *key) const;
   TObject **GetObjectRef(const TObject *obj) const { return fTable->GetObjectRef(obj); }
   const THashTable *GetTable() const { return fTable; }
   TObject *GetValue(const char *keyname) const;
   TObject *GetValue(const TObject *key) const;
   Bool_t IsOwnerValue() const { return TestBit(kIsOwnerValue); }
   TObject *operator()(const char *keyname) const { return GetValue(keyname); }
   TObject *operator()(const TObject *key) const { return GetValue(key); }
   TIterator *MakeIterator(Bool_t dir = kIterForward) const;
   void Rehash(Int_t newCapacity, Bool_t checkObjValidity = kTRUE);
   TObject *Remove(TObject *key);
   TPair *RemoveEntry(TObject *key);
   virtual void SetOwnerValue(Bool_t enable = kTRUE);
   virtual void SetOwnerKeyValue(Bool_t ownkeys = kTRUE, Bool_t ownvals = kTRUE);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TMap::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TMap::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMap.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 92; } //A (key,value) map
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TPair                                                                //
//                                                                      //
// Class used by TMap to store (key,value) pairs.                       //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TPair : public TObject {

private:
   TObject *fKey;
   TObject *fValue;

   TPair& operator=(const TPair&); // Not implemented

public:
   TPair(TObject *key, TObject *value) : fKey(key), fValue(value) { }
   TPair(const TPair &a) : TObject(), fKey(a.fKey), fValue(a.fValue) { }
   virtual ~TPair() { }
   Bool_t IsFolder() const { return kTRUE;}
   virtual void Browse(TBrowser *b);
   const char *GetName() const { return fKey->GetName(); }
   const char *GetTitle() const { return fKey->GetTitle(); }
   ULong_t Hash() const { return fKey->Hash(); }
   Bool_t IsEqual(const TObject *obj) const { return fKey->IsEqual(obj); }
   TObject *Key() const { return fKey; }
   TObject *Value() const { return fValue; }
   void SetValue(TObject *val) { fValue = val; }

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TPair::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TPair::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMap.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 126; }; // Pair TObject*, TObject*
};

typedef TPair TAssoc; // for backward compatibility


// Preventing warnings with -Weffc++ in GCC since it is a false positive for the TMapIter destructor.





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMapIter                                                             //
//                                                                      //
// Iterator of a map.                                                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TMapIter : public TIterator,
                 public std::iterator<std::bidirectional_iterator_tag,
                                      TObject*, std::ptrdiff_t,
                                      const TObject**, const TObject*&> {

private:
   const TMap *fMap; //map being iterated
   THashTableIter *fCursor; //current position in map
   Bool_t fDirection; //iteration direction

   TMapIter() : fMap(0), fCursor(0), fDirection(kIterForward) { }

public:
   TMapIter(const TMap *map, Bool_t dir = kIterForward);
   TMapIter(const TMapIter &iter);
   ~TMapIter();
   TIterator &operator=(const TIterator &rhs);
   TMapIter &operator=(const TMapIter &rhs);

   const TCollection *GetCollection() const { return fMap; }
   TObject *Next();
   void Reset();
   Bool_t operator!=(const TIterator &aIter) const;
   Bool_t operator!=(const TMapIter &aIter) const;
   TObject *operator*() const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TMapIter::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TMapIter::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMap.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 172; } //Map iterator
};
# 29 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFile.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TUrl.h" 1
// @(#)root/base:$Id: TUrl.h 33098 2010-04-19 22:54:51Z rdm $
// Author: Fons Rademakers   17/01/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TUrl                                                                 //
//                                                                      //
// This class represents a WWW compatible URL.                          //
// It provides member functions to return the different parts of        //
// an URL. The supported url format is:                                 //
//  [proto://][user[:passwd]@]host[:port]/file.ext[#anchor][?options]   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 38 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TUrl.h"
class THashList;
class TMap;

class TUrl : public TObject {

private:
   mutable TString fUrl; // full URL
   TString fProtocol; // protocol: http, ftp, news, root, proof, ...
   TString fUser; // user name
   TString fPasswd; // password
   TString fHost; // remote host
   TString fFile; // remote object
   TString fAnchor; // anchor in object (after #)
   TString fOptions; // options/search (after ?)
   mutable TString fFileOA; //!file with option and anchor
   mutable TString fHostFQ; //!fully qualified host name
   Int_t fPort; // port through which to contact remote server
   mutable TMap *fOptionsMap; //!map containing options key/value pairs

   static TObjArray *fgSpecialProtocols; // list of special protocols
   static THashList *fgHostFQDNs; // list of resolved host FQDNs

   void FindFile(char *u, Bool_t stripDoubleSlash = kTRUE);

   enum EStatusBits { kUrlWithDefaultPort = (1ULL << (14)), kUrlHasDefaultPort = (1ULL << (15)) };

public:
   TUrl() : fUrl(), fProtocol(), fUser(), fPasswd(), fHost(), fFile(),
            fAnchor(), fOptions(), fFileOA(), fHostFQ(), fPort(-1), fOptionsMap(0) { }
   TUrl(const char *url, Bool_t defaultIsFile = kFALSE);
   TUrl(const TUrl &url);
   TUrl &operator=(const TUrl &rhs);
   virtual ~TUrl();

   const char *GetUrl(Bool_t withDeflt = kFALSE) const;
   const char *GetProtocol() const { return fProtocol; }
   const char *GetUser() const { return fUser; }
   const char *GetPasswd() const { return fPasswd; }
   const char *GetHost() const { return fHost; }
   const char *GetHostFQDN() const;
   const char *GetFile() const { return fFile; }
   const char *GetAnchor() const { return fAnchor; }
   const char *GetOptions() const { return fOptions; }
   const char *GetValueFromOptions(const char *key) const;
   Int_t GetIntValueFromOptions(const char *key) const;
   void ParseOptions() const;
   void CleanRelativePath();
   const char *GetFileAndOptions() const;
   Int_t GetPort() const { return fPort; }
   Bool_t IsValid() const { return fPort == -1 ? kFALSE : kTRUE; }

   void SetProtocol(const char *proto, Bool_t setDefaultPort = kFALSE);
   void SetUser(const char *user) { fUser = user; fUrl = ""; }
   void SetPasswd(const char *pw) { fPasswd = pw; fUrl = ""; }
   void SetHost(const char *host) { fHost = host; fUrl = ""; }
   void SetFile(const char *file) { fFile = file; fUrl = ""; fFileOA = "";}
   void SetAnchor(const char *anchor) { fAnchor = anchor; fUrl = ""; fFileOA = ""; }
   void SetOptions(const char *opt) { fOptions = opt; fUrl = ""; fFileOA = ""; }
   void SetPort(Int_t port) { fPort = port; fUrl = ""; }
   void SetUrl(const char *url, Bool_t defaultIsFile = kFALSE);

   Bool_t IsSortable() const { return kTRUE; }
   Int_t Compare(const TObject *obj) const;

   void Print(Option_t *option="") const;

   static TObjArray *GetSpecialProtocols();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TUrl::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TUrl::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TUrl.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 106; } //Represents an URL
};
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFile.h" 2


class TFree;
class TArrayC;
class TArchiveFile;
class TFileOpenHandle;
class TFileCacheRead;
class TFileCacheWrite;
class TProcessID;
class TStopwatch;
class TFilePrefetch;

class TFile : public TDirectoryFile {
  friend class TDirectoryFile;
  friend class TFilePrefetch;

public:
   // Asynchronous open request status
   enum EAsyncOpenStatus { kAOSNotAsync = -1, kAOSFailure = 0,
                           kAOSInProgress = 1, kAOSSuccess = 2 };
   // Open timeout constants
   enum EOpenTimeOut { kInstantTimeout = 0, kEternalTimeout = 999999999 };

protected:
   Double_t fSumBuffer; //Sum of buffer sizes of objects written so far
   Double_t fSum2Buffer; //Sum of squares of buffer sizes of objects written so far
   Long64_t fBytesWrite; //Number of bytes written to this file
   Long64_t fBytesRead; //Number of bytes read from this file
   Long64_t fBytesReadExtra; //Number of extra bytes (overhead) read by the readahead buffer
   Long64_t fBEGIN; //First used byte in file
   Long64_t fEND; //Last used byte in file
   Long64_t fSeekFree; //Location on disk of free segments structure
   Long64_t fSeekInfo; //Location on disk of StreamerInfo record
   Int_t fD; //File descriptor
   Int_t fVersion; //File format version
   Int_t fCompress; //Compression level and algorithm
   Int_t fNbytesFree; //Number of bytes for free segments structure
   Int_t fNbytesInfo; //Number of bytes for StreamerInfo record
   Int_t fWritten; //Number of objects written so far
   Int_t fNProcessIDs; //Number of TProcessID written to this file
   Int_t fReadCalls; //Number of read calls ( not counting the cache calls )
   TString fRealName; //Effective real file name (not original url)
   TString fOption; //File options
   Char_t fUnits; //Number of bytes for file pointers
   TList *fFree; //Free segments linked list table
   TArrayC *fClassIndex; //!Index of TStreamerInfo classes written to this file
   TObjArray *fProcessIDs; //!Array of pointers to TProcessIDs
   Long64_t fOffset; //!Seek offset cache
   TArchiveFile *fArchive; //!Archive file from which we read this file
   TFileCacheRead *fCacheRead; //!Pointer to the read cache (if any)
   TMap *fCacheReadMap; //!Pointer to the read cache (if any)
   TFileCacheWrite *fCacheWrite; //!Pointer to the write cache (if any)
   Long64_t fArchiveOffset; //!Offset at which file starts in archive
   Bool_t fIsArchive; //!True if this is a pure archive file
   Bool_t fNoAnchorInName; //!True if we don't want to force the anchor to be appended to the file name
   Bool_t fIsRootFile; //!True is this is a ROOT file, raw file otherwise
   Bool_t fInitDone; //!True if the file has been initialized
   Bool_t fMustFlush; //!True if the file buffers must be flushed
   TFileOpenHandle *fAsyncHandle; //!For proper automatic cleanup
   EAsyncOpenStatus fAsyncOpenStatus; //!Status of an asynchronous open request
   TUrl fUrl; //!URL of file

   TList *fInfoCache; //!Cached list of the streamer infos in this file
   TList *fOpenPhases; //!Time info about open phases

   static TList *fgAsyncOpenRequests; //List of handles for pending open requests

   static TString fgCacheFileDir; //Directory where to locally stage files
   static Bool_t fgCacheFileDisconnected; //Indicates, we trust in the files in the cache dir without stat on the cached file
   static Bool_t fgCacheFileForce; //Indicates, to force all READ to CACHEREAD
   static UInt_t fgOpenTimeout; //Timeout for open operations in ms  - 0 corresponds to blocking i/o
   static Bool_t fgOnlyStaged ; //Before the file is opened, it is checked, that the file is staged, if not, the open fails
   static Long64_t fgBytesWrite; //Number of bytes written by all TFile objects
   static Long64_t fgBytesRead; //Number of bytes read by all TFile objects
   static Long64_t fgFileCounter; //Counter for all opened files
   static Int_t fgReadCalls; //Number of bytes read from all TFile objects
   static Int_t fgReadaheadSize; //Readahead buffer size
   static Bool_t fgReadInfo; //if true (default) ReadStreamerInfo is called when opening a file

   virtual EAsyncOpenStatus GetAsyncOpenStatus() { return fAsyncOpenStatus; }
   virtual void Init(Bool_t create);
   Bool_t FlushWriteCache();
   Int_t ReadBufferViaCache(char *buf, Int_t len);
   Int_t WriteBufferViaCache(const char *buf, Int_t len);

   // Creating projects
   Int_t MakeProjectParMake(const char *packname, const char *filename);
   Int_t MakeProjectParProofInf(const char *packname, const char *proofinfdir);

   // Interface to basic system I/O routines
   virtual Int_t SysOpen(const char *pathname, Int_t flags, UInt_t mode);
   virtual Int_t SysClose(Int_t fd);
   virtual Int_t SysRead(Int_t fd, void *buf, Int_t len);
   virtual Int_t SysWrite(Int_t fd, const void *buf, Int_t len);
   virtual Long64_t SysSeek(Int_t fd, Long64_t offset, Int_t whence);
   virtual Int_t SysStat(Int_t fd, Long_t *id, Long64_t *size, Long_t *flags, Long_t *modtime);
   virtual Int_t SysSync(Int_t fd);

   // Interface for text-based TDirectory I/O
   virtual Long64_t DirCreateEntry(TDirectory*) { return 0; }
   virtual Int_t DirReadKeys(TDirectory*) { return 0; }
   virtual void DirWriteKeys(TDirectory*) {}
   virtual void DirWriteHeader(TDirectory*) {}

private:
   TFile(const TFile &); //Files cannot be copied
   void operator=(const TFile &);

   static void CpProgress(Long64_t bytesread, Long64_t size, TStopwatch &watch);
   static TFile *OpenFromCache(const char *name, Option_t * = "",
                               const char *ftitle = "", Int_t compress = 1,
                               Int_t netopt = 0);

public:
   // TFile status bits
   enum EStatusBits {
      kRecovered = (1ULL << (10)),
      kHasReferences = (1ULL << (11)),
      kDevNull = (1ULL << (12)),
      kWriteError = (1ULL << (14)), // BIT(13) is taken up by TObject
      kBinaryFile = (1ULL << (15)),
      kRedirected = (1ULL << (16))
   };
   enum ERelativeTo { kBeg = 0, kCur = 1, kEnd = 2 };
   enum { kStartBigFile = 2000000000 };
   // File type
   enum EFileType { kDefault = 0, kLocal = 1, kNet = 2, kWeb = 3, kFile = 4, kMerge = 5};

   TFile();
   TFile(const char *fname, Option_t *option="", const char *ftitle="", Int_t compress=1);
   virtual ~TFile();
   virtual void Close(Option_t *option=""); // *MENU*
   virtual void Copy(TObject &) const { MayNotUse("Copy(TObject &)"); }
   virtual Bool_t Cp(const char *dst, Bool_t progressbar = kTRUE,UInt_t buffersize = 1000000);
   virtual TKey* CreateKey(TDirectory* mother, const TObject* obj, const char* name, Int_t bufsize);
   virtual TKey* CreateKey(TDirectory* mother, const void* obj, const TClass* cl,
                                 const char* name, Int_t bufsize);
   static TFile *&CurrentFile(); // Return the current file for this thread.
   virtual void Delete(const char *namecycle="");
   virtual void Draw(Option_t *option="");
   virtual void DrawMap(const char *keys="*",Option_t *option=""); // *MENU*
   virtual void FillBuffer(char *&buffer);
   virtual void Flush();
   TArchiveFile *GetArchive() const { return fArchive; }
   Long64_t GetArchiveOffset() const { return fArchiveOffset; }
   Int_t GetBestBuffer() const;
   virtual Int_t GetBytesToPrefetch() const;
   TFileCacheRead *GetCacheRead(TObject* tree = 0) const;
   TFileCacheWrite *GetCacheWrite() const;
   TArrayC *GetClassIndex() const { return fClassIndex; }
   Int_t GetCompressionAlgorithm() const;
   Int_t GetCompressionLevel() const;
   Int_t GetCompressionSettings() const;
   Float_t GetCompressionFactor();
   virtual Long64_t GetEND() const { return fEND; }
   virtual Int_t GetErrno() const;
   virtual void ResetErrno() const;
   Int_t GetFd() const { return fD; }
   virtual const TUrl *GetEndpointUrl() const { return &fUrl; }
   TObjArray *GetListOfProcessIDs() const {return fProcessIDs;}
   TList *GetListOfFree() const { return fFree; }
   virtual Int_t GetNfree() const { return fFree->GetSize(); }
   virtual Int_t GetNProcessIDs() const { return fNProcessIDs; }
   Option_t *GetOption() const { return fOption.Data(); }
   virtual Long64_t GetBytesRead() const { return fBytesRead; }
   virtual Long64_t GetBytesReadExtra() const { return fBytesReadExtra; }
   virtual Long64_t GetBytesWritten() const;
   virtual Int_t GetReadCalls() const { return fReadCalls; }
   Int_t GetVersion() const { return fVersion; }
   Int_t GetRecordHeader(char *buf, Long64_t first, Int_t maxbytes,
                                       Int_t &nbytes, Int_t &objlen, Int_t &keylen);
   virtual Int_t GetNbytesInfo() const {return fNbytesInfo;}
   virtual Int_t GetNbytesFree() const {return fNbytesFree;}
   Long64_t GetRelOffset() const { return fOffset - fArchiveOffset; }
   virtual Long64_t GetSeekFree() const {return fSeekFree;}
   virtual Long64_t GetSeekInfo() const {return fSeekInfo;}
   virtual Long64_t GetSize() const;
   virtual TList *GetStreamerInfoList();
   const TList *GetStreamerInfoCache();
   virtual void IncrementProcessIDs() { fNProcessIDs++; }
   virtual Bool_t IsArchive() const { return fIsArchive; }
           Bool_t IsBinary() const { return TestBit(kBinaryFile); }
           Bool_t IsRaw() const { return !fIsRootFile; }
   virtual Bool_t IsOpen() const;
   virtual void ls(Option_t *option="") const;
   virtual void MakeFree(Long64_t first, Long64_t last);
   virtual void MakeProject(const char *dirname, const char *classes="*",
                                   Option_t *option="new"); // *MENU*
   virtual void Map(); // *MENU*
   virtual Bool_t Matches(const char *name);
   virtual Bool_t MustFlush() const {return fMustFlush;}
   virtual void Paint(Option_t *option="");
   virtual void Print(Option_t *option="") const;
   virtual Bool_t ReadBufferAsync(Long64_t offs, Int_t len);
   virtual Bool_t ReadBuffer(char *buf, Int_t len);
   virtual Bool_t ReadBuffer(char *buf, Long64_t pos, Int_t len);
   virtual Bool_t ReadBuffers(char *buf, Long64_t *pos, Int_t *len, Int_t nbuf);
   virtual void ReadFree();
   virtual TProcessID *ReadProcessID(UShort_t pidf);
   virtual void ReadStreamerInfo();
   virtual Int_t Recover();
   virtual Int_t ReOpen(Option_t *mode);
   virtual void Seek(Long64_t offset, ERelativeTo pos = kBeg);
   virtual void SetCacheRead(TFileCacheRead *cache, TObject* tree = 0);
   virtual void SetCacheWrite(TFileCacheWrite *cache);
   virtual void SetCompressionAlgorithm(Int_t algorithm=0);
   virtual void SetCompressionLevel(Int_t level=1);
   virtual void SetCompressionSettings(Int_t settings=1);
   virtual void SetEND(Long64_t last) { fEND = last; }
   virtual void SetOffset(Long64_t offset, ERelativeTo pos = kBeg);
   virtual void SetOption(Option_t *option=">") { fOption = option; }
   virtual void SetReadCalls(Int_t readcalls = 0) { fReadCalls = readcalls; }
   virtual void ShowStreamerInfo();
   virtual Int_t Sizeof() const;
   void SumBuffer(Int_t bufsize);
   virtual void UseCache(Int_t maxCacheSize = 10, Int_t pageSize = 0);
   virtual Bool_t WriteBuffer(const char *buf, Int_t len);
   virtual Int_t Write(const char *name=0, Int_t opt=0, Int_t bufsiz=0);
   virtual Int_t Write(const char *name=0, Int_t opt=0, Int_t bufsiz=0) const;
   virtual void WriteFree();
   virtual void WriteHeader();
   virtual UShort_t WriteProcessID(TProcessID *pid);
   virtual void WriteStreamerInfo();

   static TFileOpenHandle
                      *AsyncOpen(const char *name, Option_t *option = "",
                                 const char *ftitle = "", Int_t compress = 1,
                                 Int_t netopt = 0);
   static TFile *Open(const char *name, Option_t *option = "",
                            const char *ftitle = "", Int_t compress = 1,
                            Int_t netopt = 0);
   static TFile *Open(TFileOpenHandle *handle);

   static EFileType GetType(const char *name, Option_t *option = "", TString *prefix = 0);

   static EAsyncOpenStatus GetAsyncOpenStatus(const char *name);
   static EAsyncOpenStatus GetAsyncOpenStatus(TFileOpenHandle *handle);
   static const TUrl *GetEndpointUrl(const char *name);

   static Long64_t GetFileBytesRead();
   static Long64_t GetFileBytesWritten();
   static Int_t GetFileReadCalls();
   static Int_t GetReadaheadSize();

   static void SetFileBytesRead(Long64_t bytes = 0);
   static void SetFileBytesWritten(Long64_t bytes = 0);
   static void SetFileReadCalls(Int_t readcalls = 0);
   static void SetReadaheadSize(Int_t bufsize = 256000);
   static void SetReadStreamerInfo(Bool_t readinfo=kTRUE);

   static Long64_t GetFileCounter();
   static void IncrementFileCounter();

   static Bool_t SetCacheFileDir(const char *cacheDir, Bool_t operateDisconnected = kTRUE,
                                       Bool_t forceCacheread = kFALSE);
   static const char *GetCacheFileDir();
   static Bool_t ShrinkCacheFileDir(Long64_t shrinkSize, Long_t cleanupInteval = 0);
   static Bool_t Cp(const char *src, const char *dst, Bool_t progressbar = kTRUE,
                          UInt_t buffersize = 1000000);

   static UInt_t SetOpenTimeout(UInt_t timeout); // in ms
   static UInt_t GetOpenTimeout(); // in ms
   static Bool_t SetOnlyStaged(Bool_t onlystaged);
   static Bool_t GetOnlyStaged();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 8; } static void Dictionary(); virtual TClass *IsA() const { return TFile::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TFile::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFile.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 297; } //ROOT file
};





// To properly handle the use of gFile in header files (in static declarations)
extern TFile *gFile;


//
// Class holding info about the file being opened
//
class TFileOpenHandle : public TNamed {

friend class TFile;
friend class TAlienFile;

private:
   TString fOpt; // Options
   Int_t fCompress; // Compression level and algorithm
   Int_t fNetOpt; // Network options
   TFile *fFile; // TFile instance of the file being opened

   TFileOpenHandle(TFile *f) : TNamed("",""), fOpt(""), fCompress(1),
                               fNetOpt(0), fFile(f) { }
   TFileOpenHandle(const char *n, const char *o, const char *t, Int_t cmp,
                   Int_t no) : TNamed(n,t), fOpt(o), fCompress(cmp),
                               fNetOpt(no), fFile(0) { }
   TFileOpenHandle(const TFileOpenHandle&);
   TFileOpenHandle& operator=(const TFileOpenHandle&);

   TFile *GetFile() const { return fFile; }

public:
   ~TFileOpenHandle() { }

   Bool_t Matches(const char *name);

   const char *GetOpt() const { return fOpt; }
   Int_t GetCompress() const { return fCompress; }
   Int_t GetNetOpt() const { return fNetOpt; }
};

//______________________________________________________________________________
inline Int_t TFile::GetCompressionAlgorithm() const
{
   return (fCompress < 0) ? -1 : fCompress / 100;
}

//______________________________________________________________________________
inline Int_t TFile::GetCompressionLevel() const
{
   return (fCompress < 0) ? -1 : fCompress % 100;
}

//______________________________________________________________________________
inline Int_t TFile::GetCompressionSettings() const
{
   return (fCompress < 0) ? -1 : fCompress;
}
# 3 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h" 1
// @(#)root/hist:$Id: TF1.h 36906 2010-11-24 15:52:01Z moneta $
// Author: Rene Brun   18/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
// ---------------------------------- F1.h






//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TF1                                                                  //
//                                                                      //
// The Parametric 1-D function                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFormula.h" 1
// @(#)root/hist:$Id: TFormula.h 30176 2009-09-15 15:42:11Z pcanal $
// Author: Nicolas Brun   19/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
// ---------------------------------- Formula.h






//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TFormula                                                             //
//                                                                      //
// The formula base class  f(x,y,z,par)                                 //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBits.h" 1
// @(#)root/cont:$Id: TBits.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Philippe Canal 05/02/01

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TBits                                                                //
//                                                                      //
// Container of bits.                                                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 33 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBits.h"
class TBits : public TObject {

protected:

   UInt_t fNbits; // Highest bit set + 1
   UInt_t fNbytes; // Number of UChars in fAllBits
   UChar_t *fAllBits; //[fNbytes] array of UChars

   void ReserveBytes(UInt_t nbytes);
   void DoAndEqual(const TBits& rhs);
   void DoOrEqual (const TBits& rhs);
   void DoXorEqual(const TBits& rhs);
   void DoLeftShift(UInt_t shift);
   void DoRightShift(UInt_t shift);
   void DoFlip();

public:
   TBits(UInt_t nbits = 8);
   TBits(const TBits&);
   TBits& operator=(const TBits&);
   virtual ~TBits();

   class TReference {
      friend class TBits;

      TBits &fBits; //!
      UInt_t fPos; //!

      TReference(); // left undefined

public:
      TReference(TBits& bit, UInt_t pos) : fBits(bit),fPos(pos) { }
      ~TReference() { }

       // For b[i] = val;
      TReference& operator=(Bool_t val);

      // For b[i] = b[__j];
      TReference& operator=(const TReference& rhs);






      // For val = b[i];
      operator Bool_t() const;
   };

   //----- bit manipulation
   //----- (note the difference with TObject's bit manipulations)
   void ResetAllBits(Bool_t value=kFALSE); // if value=1 set all bits to 1
   void ResetBitNumber(UInt_t bitnumber);
   void SetBitNumber(UInt_t bitnumber, Bool_t value = kTRUE);
   Bool_t TestBitNumber(UInt_t bitnumber) const;

   //----- Accessors and operator
   TBits::TReference operator[](UInt_t bitnumber) { return TReference(*this,bitnumber); }
   Bool_t operator[](UInt_t bitnumber) const;

   TBits& operator&=(const TBits& rhs) { DoAndEqual(rhs); return *this; }
   TBits& operator|=(const TBits& rhs) { DoOrEqual(rhs); return *this; }
   TBits& operator^=(const TBits& rhs) { DoXorEqual(rhs); return *this; }
   TBits& operator<<=(UInt_t rhs) { DoLeftShift(rhs); return *this; }
   TBits& operator>>=(UInt_t rhs) { DoRightShift(rhs); return *this; }
   TBits operator<<(UInt_t rhs) { return TBits(*this)<<= rhs; }
   TBits operator>>(UInt_t rhs) { return TBits(*this)>>= rhs; }
   TBits operator~() { TBits res(*this); res.DoFlip(); return res; }

   //----- Optimized setters
   // Each of these will replace the contents of the receiver with the bitvector
   // in the parameter array.  The number of bits is changed to nbits.  If nbits
   // is smaller than fNbits, the receiver will NOT be compacted.
   void Set(UInt_t nbits, const Char_t *array);
   void Set(UInt_t nbits, const UChar_t *array) { Set(nbits, (const Char_t*)array); }
   void Set(UInt_t nbits, const Short_t *array);
   void Set(UInt_t nbits, const UShort_t *array) { Set(nbits, (const Short_t*)array); }
   void Set(UInt_t nbits, const Int_t *array);
   void Set(UInt_t nbits, const UInt_t *array) { Set(nbits, (const Int_t*)array); }
   void Set(UInt_t nbits, const Long64_t *array);
   void Set(UInt_t nbits, const ULong64_t *array) { Set(nbits, (const Long64_t*)array); }

   //----- Optimized getters
   // Each of these will replace the contents of the parameter array with the
   // bits in the receiver.  The parameter array must be large enough to hold
   // all of the bits in the receiver.
   // Note on semantics: any bits in the parameter array that go beyond the
   // number of the bits in the receiver will have an unspecified value.  For
   // example, if you call Get(Int*) with an array of one integer and the TBits
   // object has less than 32 bits, then the remaining bits in the integer will
   // have an unspecified value.
   void Get(Char_t *array) const;
   void Get(UChar_t *array) const { Get((Char_t*)array); }
   void Get(Short_t *array) const;
   void Get(UShort_t *array) const { Get((Short_t*)array); }
   void Get(Int_t *array) const;
   void Get(UInt_t *array) const { Get((Int_t*)array); }
   void Get(Long64_t *array) const;
   void Get(ULong64_t *array) const { Get((Long64_t*)array); }

   //----- Utilities
   void Clear(Option_t *option="");
   void Compact(); // Reduce the space used.
   UInt_t CountBits(UInt_t startBit=0) const ; // return number of bits set to 1
   UInt_t FirstNullBit(UInt_t startBit=0) const;
   UInt_t FirstSetBit(UInt_t startBit=0) const;
   UInt_t GetNbits() const { return fNbits; }
   UInt_t GetNbytes() const { return fNbytes; }

   Bool_t operator==(const TBits &other) const;
   Bool_t operator!=(const TBits &other) const { return !(*this==other); }

   void Paint(Option_t *option=""); // to visualize the bits array as an histogram, etc
   void Print(Option_t *option="") const; // to show the list of active bits
   void Output(ostream &) const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TBits::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TBits::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBits.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 149; } // Bit container
};


inline Bool_t operator&(const TBits::TReference& lhs, const TBits::TReference& rhs)
{
   return (Bool_t)lhs & rhs;
}

inline Bool_t operator|(const TBits::TReference& lhs, const TBits::TReference& rhs)
{
   return (Bool_t)lhs | rhs;
}

inline Bool_t operator^(const TBits::TReference& lhs, const TBits::TReference& rhs)
{
   return (Bool_t)lhs ^ rhs;
}

inline TBits operator&(const TBits& lhs, const TBits& rhs)
{
   TBits result(lhs);
   result &= rhs;
   return result;
}

inline TBits operator|(const TBits& lhs, const TBits& rhs)
{
   TBits result(lhs);
   result |= rhs;
   return result;
}

inline TBits operator^(const TBits& lhs, const TBits& rhs)
{
   TBits result(lhs);
   result ^= rhs;
   return result;
}

inline ostream &operator<<(ostream& os, const TBits& rhs)
{
   rhs.Output(os); return os;
}

// inline functions...

inline void TBits::SetBitNumber(UInt_t bitnumber, Bool_t value)
{
   // Set bit number 'bitnumber' to be value

   if (bitnumber >= fNbits) {
      UInt_t new_size = (bitnumber/8) + 1;
      if (new_size > fNbytes) {
         new_size *= 2;
         UChar_t *old_location = fAllBits;
         fAllBits = new UChar_t[new_size];
         memcpy(fAllBits,old_location,fNbytes);
         memset(fAllBits+fNbytes ,0, new_size-fNbytes);
         fNbytes = new_size;
         delete [] old_location;
      }
      fNbits = bitnumber+1;
   }
   UInt_t loc = bitnumber/8;
   UChar_t bit = bitnumber%8;
   if (value)
      fAllBits[loc] |= (1<<bit);
   else
      fAllBits[loc] &= (0xFF ^ (1<<bit));
}

inline Bool_t TBits::TestBitNumber(UInt_t bitnumber) const
{
   // Return the current value of the bit

   if (bitnumber >= fNbits) return kFALSE;
   UInt_t loc = bitnumber/8;
   UChar_t value = fAllBits[loc];
   UChar_t bit = bitnumber%8;
   Bool_t result = (value & (1<<bit)) != 0;
   return result;
   // short: return 0 != (fAllBits[bitnumber/8] & (1<< (bitnumber%8)));
}

inline void TBits::ResetBitNumber(UInt_t bitnumber)
{
   SetBitNumber(bitnumber,kFALSE);
}

inline Bool_t TBits::operator[](UInt_t bitnumber) const
{
   return TestBitNumber(bitnumber);
}

inline TBits::TReference& TBits::TReference::operator=(Bool_t val)
{
   // For b[i] = val.

   fBits.SetBitNumber(fPos,val); return *this;
}

inline TBits::TReference& TBits::TReference::operator=(const TReference& rhs)
{
   // For b[i] = b[__j].

   fBits.SetBitNumber(fPos,rhs.fBits.TestBitNumber(rhs.fPos)); return *this;
}
# 267 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBits.h"
inline TBits::TReference::operator Bool_t() const
{
   // For val = b[i].

   return fBits.TestBitNumber(fPos);
}
# 31 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFormula.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjArray.h" 1
// @(#)root/cont:$Id: TObjArray.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Fons Rademakers   11/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TObjArray                                                            //
//                                                                      //
// An array of TObjects. The array expands automatically when adding    //
// elements (shrinking can be done by hand).                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <iterator.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/iterator

#pragma ifndef PREC_STL_ITERATOR
#pragma define PREC_STL_ITERATOR
#pragma link off global PREC_STL_ITERATOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from STL HP implementation 1994
// Imported from STL SGI implementation 1997 
// Imported from ANSI/ISO C++ draft Nov 1997
// Modified by Masaharu Goto
// May need improvement for the latest standard


////////////////////////////////////////////////////////////////////////
// iterator_tag
////////////////////////////////////////////////////////////////////////
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag {};
struct bidirectional_iterator_tag {};
struct random_access_iterator_tag {};

////////////////////////////////////////////////////////////////////////
// iterator template
////////////////////////////////////////////////////////////////////////
template <class T, class Distance> struct input_iterator {};
struct output_iterator {};
template <class T, class Distance> struct forward_iterator {};
template <class T, class Distance> struct bidirectional_iterator {};
template <class T, class Distance> struct random_access_iterator {};

#pragma link off class output_iterator;







////////////////////////////////////////////////////////////////////////
// iterator_category overloaded function
////////////////////////////////////////////////////////////////////////
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const input_iterator<T, Distance>&) {
    return input_iterator_tag();
}

inline output_iterator_tag iterator_category(const output_iterator&) {
    return output_iterator_tag();
}

#pragma link off function iterator_category(const output_iterator&);


template <class T, class Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<T, Distance>&) {
    return forward_iterator_tag();
}

template <class T, class Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<T, Distance>&) {
    return bidirectional_iterator_tag();
}

template <class T, class Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<T, Distance>&) {
    return random_access_iterator_tag();
}

template <class T>
inline random_access_iterator_tag
iterator_category(const T*) {
    return random_access_iterator_tag();
}


// iterator_traits, iterator and reverse_iterator template may not be
// needed for precompiled library interface 

////////////////////////////////////////////////////////////////////////
// iterator_traits
////////////////////////////////////////////////////////////////////////

template <class Iterator>
struct iterator_traits {
  typedef typename Iterator::iterator_category iterator_category;
  typedef typename Iterator::value_type value_type;
  typedef typename Iterator::difference_type difference_type;
  typedef typename Iterator::pointer pointer;
  typedef typename Iterator::reference reference;
};

// template partial specialization, implement in cint5.15.14 1587
template <class T>
struct iterator_traits<T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef T& reference;
};

// incomplete implementation in cint5.15.14 1587, need some fix
// iterator_traits<const int*> is changed as iterator_traits<const int* const>
// or something, but cint5.15.14 can not handle this well
template <class T>
struct iterator_traits<const T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef const T* pointer;
  typedef const T& reference;
};

////////////////////////////////////////////////////////////////////////
// iterator
////////////////////////////////////////////////////////////////////////
template<class Category, class T, class Distance = ptrdiff_t,
         class Pointer = T*, class Reference = T&>
struct iterator {
  typedef T value_type;
  typedef Distance difference_type;
  typedef Pointer pointer;
  typedef Reference reference;
  typedef Category iterator_category;
};


////////////////////////////////////////////////////////////////////////
// reverse_iterator
////////////////////////////////////////////////////////////////////////






template <class Iterator>
class reverse_iterator
# 166 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
{




 public:
# 181 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
   typedef Iterator::pointer pointer;
   typedef Iterator::reference reference;
   typedef ptrdiff_t difference_type;


   reverse_iterator();
   //reverse_iterator(Iterator x);



   Iterator base() const; // explicit
   reference operator*() const;
   pointer operator->() const;
   reverse_iterator& operator++();
   reverse_iterator operator++(int);
   reverse_iterator& operator--();
   reverse_iterator operator--(int);
   reverse_iterator operator+ (difference_type n) const;
   reverse_iterator& operator+=(difference_type n);
   reverse_iterator operator- (difference_type n) const;
   reverse_iterator& operator-=(difference_type n);
   reference operator[](difference_type n) const;
};
# 932 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
// for g++ 3.1,3.2
namespace __gnu_cxx
{
  // This iterator adapter is 'normal' in the sense that it does not
  // change the semantics of any of the operators of its iterator
  // parameter.  Its primary purpose is to convert an iterator that is
  // not a class, e.g. a pointer, into an iterator that is a class.
  // The _Container parameter exists solely so that different containers
  // using this template can instantiate different types, even if the
  // _Iterator parameter is the same.
  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
      : public iterator<typename iterator_traits<_Iterator>::iterator_category,
                        typename iterator_traits<_Iterator>::value_type,
                        typename iterator_traits<_Iterator>::difference_type,
                        typename iterator_traits<_Iterator>::pointer,
                        typename iterator_traits<_Iterator>::reference>
    {
    protected:
      _Iterator _M_current;

    public:
      typedef typename iterator_traits<_Iterator>::difference_type
                    difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

      __normal_iterator() : _M_current(_Iterator()) { }

      explicit
      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

      // Allow iterator to const_iterator conversion
      template<typename _Iter>
      inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
 : _M_current(__i.base()) { }

      // Forward iterator requirements
      reference
      operator*() const { return *_M_current; }

      pointer
      operator->() const { return _M_current; }

      __normal_iterator&
      operator++() { ++_M_current; return *this; }

      __normal_iterator
      operator++(int) { return __normal_iterator(_M_current++); }

      // Bidirectional iterator requirements
      __normal_iterator&
      operator--() { --_M_current; return *this; }

      __normal_iterator
      operator--(int) { return __normal_iterator(_M_current--); }

      // Random access iterator requirements
      reference
      operator[](const difference_type& __n) const
      { return _M_current[__n]; }

      __normal_iterator&
      operator+=(const difference_type& __n)
      { _M_current += __n; return *this; }

      __normal_iterator
      operator+(const difference_type& __n) const
      { return __normal_iterator(_M_current + __n); }

      __normal_iterator&
      operator-=(const difference_type& __n)
      { _M_current -= __n; return *this; }

      __normal_iterator
      operator-(const difference_type& __n) const
      { return __normal_iterator(_M_current - __n); }

      const _Iterator&
      base() const { return _M_current; }
    };

  // Note: In what follows, the left- and right-hand-side iterators are
  // allowed to vary in types (conceptually in cv-qualification) so that
  // comparaison between cv-qualified and non-cv-qualified iterators be
  // valid.  However, the greedy and unfriendly operators in std::rel_ops
  // will make overload resolution ambiguous (when in scope) if we don't
  // provide overloads whose operands are of the same type.  Can someone
  // remind me what generic programming is about? -- Gaby

  // Forward iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  // Random access iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  // _GLIBCPP_RESOLVE_LIB_DEFECTS
  // According to the resolution of DR179 not only the various comparison
  // operators but also operator- must accept mixed iterator/const_iterator
  // parameters.
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
     const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
} // namespace __gnu_cxx







#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 2
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/iterator" 2
}
# 30 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjArray.h" 2


// Prevent -Weffc++ from complaining about the inheritance
// TObjArrayIter from std::iterator.
       
# 35 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjArray.h" 3


class TObjArrayIter;

class TObjArray : public TSeqCollection {

friend class TObjArrayIter;
friend class TClonesArray;

protected:
   TObject **fCont; //!Array contents
   Int_t fLowerBound; //Lower bound of the array
   Int_t fLast; //Last element in array containing an object

   Bool_t BoundsOk(const char *where, Int_t at) const;
   void Init(Int_t s, Int_t lowerBound);
   Bool_t OutOfBoundsError(const char *where, Int_t i) const;
   Int_t GetAbsLast() const;

public:
   typedef TObjArrayIter Iterator_t;

   TObjArray(Int_t s = TCollection::kInitCapacity, Int_t lowerBound = 0);
   TObjArray(const TObjArray &a);
   virtual ~TObjArray();
   TObjArray& operator=(const TObjArray&);
   virtual void Clear(Option_t *option="");
   virtual void Compress();
   virtual void Delete(Option_t *option="");
   virtual void Expand(Int_t newSize); // expand or shrink an array
   Int_t GetEntries() const;
   Int_t GetEntriesFast() const {
      return GetAbsLast() + 1; //only OK when no gaps
   }
   Int_t GetLast() const;
   TObject **GetObjectRef() const { return fCont; };
   TObject **GetObjectRef(const TObject *obj) const;
   Bool_t IsEmpty() const { return GetAbsLast() == -1; }
   TIterator *MakeIterator(Bool_t dir = kIterForward) const;

   void Add(TObject *obj) { AddLast(obj); }
   virtual void AddFirst(TObject *obj);
   virtual void AddLast(TObject *obj);
   virtual void AddAt(TObject *obj, Int_t idx);
   virtual void AddAtAndExpand(TObject *obj, Int_t idx);
   virtual Int_t AddAtFree(TObject *obj);
   virtual void AddAfter(const TObject *after, TObject *obj);
   virtual void AddBefore(const TObject *before, TObject *obj);
   virtual TObject *FindObject(const char *name) const;
   virtual TObject *FindObject(const TObject *obj) const;
   virtual TObject *RemoveAt(Int_t idx);
   virtual TObject *Remove(TObject *obj);
   virtual void RemoveRange(Int_t idx1, Int_t idx2);
   virtual void RecursiveRemove(TObject *obj);

   TObject *At(Int_t idx) const;
   TObject *UncheckedAt(Int_t i) const { return fCont[i-fLowerBound]; }
   TObject *Before(const TObject *obj) const;
   TObject *After(const TObject *obj) const;
   TObject *First() const;
   TObject *Last() const;
   virtual TObject *&operator[](Int_t i);
   virtual TObject *operator[](Int_t i) const;
   Int_t LowerBound() const { return fLowerBound; }
   Int_t IndexOf(const TObject *obj) const;
   void SetLast(Int_t last);

   virtual void Randomize(Int_t ntimes=1);
   virtual void Sort(Int_t upto = kMaxInt);
   virtual Int_t BinarySearch(TObject *obj, Int_t upto = kMaxInt); // the TObjArray has to be sorted, -1 == not found !!

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TObjArray::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TObjArray::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjArray.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 106; } //An array of objects
};


// Preventing warnings with -Weffc++ in GCC since it is a false positive for the TObjArrayIter destructor.





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TObjArrayIter                                                        //
//                                                                      //
// Iterator of object array.                                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TObjArrayIter : public TIterator,
                      public std::iterator<std::bidirectional_iterator_tag, // TODO: ideally it should be a  randomaccess_iterator_tag
                                           TObject*, std::ptrdiff_t,
                                           const TObject**, const TObject*&> {

private:
   const TObjArray *fArray; //array being iterated
   Int_t fCurCursor; //current position in array
   Int_t fCursor; //next position in array
   Bool_t fDirection; //iteration direction

   TObjArrayIter() : fArray(0), fCurCursor(0), fCursor(0), fDirection(kIterForward) { }

public:
   TObjArrayIter(const TObjArray *arr, Bool_t dir = kIterForward);
   TObjArrayIter(const TObjArrayIter &iter);
   ~TObjArrayIter() { }
   TIterator &operator=(const TIterator &rhs);
   TObjArrayIter &operator=(const TObjArrayIter &rhs);

   const TCollection *GetCollection() const { return fArray; }
   TObject *Next();
   void Reset();
   Bool_t operator!=(const TIterator &aIter) const;
   Bool_t operator!=(const TObjArrayIter &aIter) const;
   TObject *operator*() const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TObjArrayIter::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TObjArrayIter::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjArray.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 151; } //Object array iterator
};





//---- inlines -----------------------------------------------------------------

inline Bool_t TObjArray::BoundsOk(const char *where, Int_t at) const
{
   return (at < fLowerBound || at-fLowerBound >= fSize)
                  ? OutOfBoundsError(where, at)
                  : kTRUE;
}

inline TObject *TObjArray::At(Int_t i) const
{
   // Return the object at position i. Returns 0 if i is out of bounds.
   int j = i-fLowerBound;
   if (j >= 0 && j < fSize) return fCont[j];
   BoundsOk("At", i);
   return 0;
}
# 34 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFormula.h" 2


class TFormulaPrimitive;

const Int_t kMAXFOUND = 500;
const Int_t kTFOperMask = 0x7fffff;
const UChar_t kTFOperShift = 23;


class TOperOffset {
   friend class TFormula;
public:
   enum {
      kVariable = 0,
      kParameter = 1,
      kConstant = 2
   };
   TOperOffset();
protected:
   Short_t fType0; // type     of operand  0
   Short_t fOffset0; // offset   of operand  0
   Short_t fType1; // type     of operand  1
   Short_t fOffset1; // offset   of operand  1
   Short_t fType2; // type     of operand  2
   Short_t fOffset2; // offset   of operand  2
   Short_t fType3; // type     of operand  3
   Short_t fOffset3; // offset   of operand  3
   Short_t fToJump; // where to jump in case of optimized boolen
   Short_t fOldAction; // temporary variable used during optimization
};

class TFormula : public TNamed {

protected:

   typedef Double_t (TObject::*TFuncG)(const Double_t*,const Double_t*) const;

   Int_t fNdim; //Dimension of function (1=1-Dim, 2=2-Dim,etc)
   Int_t fNpar; //Number of parameters
   Int_t fNoper; //Number of operators
   Int_t fNconst; //Number of constants
   Int_t fNumber; //formula number identifier
   Int_t fNval; //Number of different variables in expression
   Int_t fNstring; //Number of different constants character strings
   TString *fExpr; //[fNoper] List of expressions
private:
   Int_t *fOper; //[fNoper] List of operators. (See documentation for changes made at version 7)
protected:
   Double_t *fConst; //[fNconst] Array of fNconst formula constants
   Double_t *fParams; //[fNpar] Array of fNpar parameters
   TString *fNames; //[fNpar] Array of parameter names
   TObjArray fFunctions; //Array of function calls to make
   TObjArray fLinearParts; //Linear parts if the formula is linear (contains '|' or "++")

   TBits fAlreadyFound; //! cache for information

   // Optimized expression
   Int_t fNOperOptimized; //!Number of operators after optimization
   TString *fExprOptimized; //![fNOperOptimized] List of expressions
   Int_t *fOperOptimized; //![fNOperOptimized] List of operators. (See documentation for changes made at version 7)
   TOperOffset *fOperOffset; //![fNOperOptimized]         Offsets of operrands
   TFormulaPrimitive **fPredefined; //![fNPar] predefined function  
   TFuncG fOptimal; //!pointer to optimal function

   Int_t PreCompile();
   virtual Bool_t CheckOperands(Int_t operation, Int_t &err);
   virtual Bool_t CheckOperands(Int_t leftoperand, Int_t rightoperartion, Int_t &err);
   virtual Bool_t StringToNumber(Int_t code);
   void MakePrimitive(const char *expr, Int_t pos);
   inline Int_t *GetOper() const { return fOper; }
   inline Short_t GetAction(Int_t code) const { return fOper[code] >> kTFOperShift; }
   inline Int_t GetActionParam(Int_t code) const { return fOper[code] & kTFOperMask; }

   inline void SetAction(Int_t code, Int_t value, Int_t param = 0) {
      fOper[code] = (value) << kTFOperShift;
      fOper[code] += param;
   }
   inline Int_t *GetOperOptimized() const { return fOperOptimized; }
   inline Short_t GetActionOptimized(Int_t code) const { return fOperOptimized[code] >> kTFOperShift; }
   inline Int_t GetActionParamOptimized(Int_t code) const { return fOperOptimized[code] & kTFOperMask; }

   inline void SetActionOptimized(Int_t code, Int_t value, Int_t param = 0) {
      fOperOptimized[code] = (value) << kTFOperShift;
      fOperOptimized[code] += param;
   }

   void ClearFormula(Option_t *option="");
   virtual Bool_t IsString(Int_t oper) const;

   virtual void Convert(UInt_t fromVersion);
   //
   // Functions  - used for formula evaluation
   Double_t EvalParFast(const Double_t *x, const Double_t *params);
   Double_t EvalPrimitive(const Double_t *x, const Double_t *params);
   Double_t EvalPrimitive0(const Double_t *x, const Double_t *params);
   Double_t EvalPrimitive1(const Double_t *x, const Double_t *params);
   Double_t EvalPrimitive2(const Double_t *x, const Double_t *params);
   Double_t EvalPrimitive3(const Double_t *x, const Double_t *params);
   Double_t EvalPrimitive4(const Double_t *x, const Double_t *params);

   // Action code for Version 6 and above.
   enum {
      kEnd = 0,
      kAdd = 1, kSubstract = 2,
      kMultiply = 3, kDivide = 4,
      kModulo = 5,

      kcos = 10, ksin = 11 , ktan = 12,
      kacos = 13, kasin = 14 , katan = 15,
      katan2 = 16,
      kfmod = 17,

      kpow = 20, ksq = 21, ksqrt = 22,

      kstrstr = 23,

      kmin = 24, kmax = 25,

      klog = 30, kexp = 31, klog10 = 32,

      kpi = 40,

      kabs = 41 , ksign= 42,
      kint = 43 ,
      kSignInv= 44 ,
      krndm = 50 ,

      kAnd = 60, kOr = 61,
      kEqual = 62, kNotEqual = 63,
      kLess = 64, kGreater = 65,
      kLessThan = 66, kGreaterThan = 67,
      kNot = 68,

      kcosh = 70 , ksinh = 71, ktanh = 72,
      kacosh = 73 , kasinh = 74, katanh = 75,

      kStringEqual = 76, kStringNotEqual = 77,

      kBitAnd = 78, kBitOr = 79,
      kLeftShift = 80, kRightShift = 81,

      kJumpIf = 82, kJump = 83,

      kexpo = 100 , kxexpo = 100, kyexpo = 101, kzexpo = 102, kxyexpo = 105,
      kgaus = 110 , kxgaus = 110, kygaus = 111, kzgaus = 112, kxygaus = 115,
      klandau = 120 , kxlandau = 120, kylandau = 121, kzlandau = 122, kxylandau = 125,
      kpol = 130 , kxpol = 130, kypol = 131, kzpol = 132,

      kParameter = 140,
      kConstant = 141,
      kBoolOptimize = 142,
      kStringConst = 143,
      kVariable = 144,
      kFunctionCall = 145,
      kData = 146,
      kUnary = 147,
      kBinary = 148,
      kThree = 149,
      kDefinedVariable = 150,
      kDefinedString = 151,
      //
      kPlusD = 152,
      kPlusDD = 153,
      kMultD = 154,
      kMultDD = 155,
      kBoolOptimizeOr = 156,
      kBoolOptimizeAnd = 157,
      kBoolSet = 158,
      kFDM = 159,
      kFD0 = 160,
      kFD1 = 161,
      kFD2 = 162,
      kFD3 = 163
   };

public:
   // TFormula status bits
   enum {
      kNotGlobal = (1ULL << (10)), // don't store in gROOT->GetListOfFunction
      kNormalized = (1ULL << (14)), // set to true if the function (ex gausn) is normalized
      kLinear = (1ULL << (16)) //set to true if the function is for linear fitting
   };

               TFormula();
               TFormula(const char *name,const char *formula);
               TFormula(const TFormula &formula);
   TFormula& operator=(const TFormula &rhs);
   virtual ~TFormula();

 public:
   void Optimize();
   virtual void Analyze(const char *schain, Int_t &err, Int_t offset=0);
   virtual Bool_t AnalyzeFunction(TString &chaine, Int_t &err, Int_t offset=0);
   virtual Int_t Compile(const char *expression="");
   virtual void Copy(TObject &formula) const;
   virtual void Clear(Option_t *option="");
   virtual char *DefinedString(Int_t code);
   virtual Double_t DefinedValue(Int_t code);
   virtual Int_t DefinedVariable(TString &variable,Int_t &action);
   virtual Double_t Eval(Double_t x, Double_t y=0, Double_t z=0, Double_t t=0) const;
   virtual Double_t EvalParOld(const Double_t *x, const Double_t *params=0);
   virtual Double_t EvalPar(const Double_t *x, const Double_t *params=0){return ((*this).*fOptimal)(x,params);};
   virtual const TObject *GetLinearPart(Int_t i);
   virtual Int_t GetNdim() const {return fNdim;}
   virtual Int_t GetNpar() const {return fNpar;}
   virtual Int_t GetNumber() const {return fNumber;}
   virtual TString GetExpFormula(Option_t *option="") const;
   Double_t GetParameter(Int_t ipar) const;
   Double_t GetParameter(const char *name) const;
   virtual Double_t *GetParameters() const {return fParams;}
   virtual void GetParameters(Double_t *params){for(Int_t i=0;i<fNpar;i++) params[i] = fParams[i];}
   virtual const char *GetParName(Int_t ipar) const;
   virtual Int_t GetParNumber(const char *name) const;
   virtual Bool_t IsLinear() {return TestBit(kLinear);}
   virtual Bool_t IsNormalized() {return TestBit(kNormalized);}
   virtual void Print(Option_t *option="") const; // *MENU*
   virtual void ProcessLinear(TString &replaceformula);
   virtual void SetNumber(Int_t number) {fNumber = number;}
   virtual void SetParameter(const char *name, Double_t parvalue);
   virtual void SetParameter(Int_t ipar, Double_t parvalue);
   virtual void SetParameters(const Double_t *params);
   virtual void SetParameters(Double_t p0,Double_t p1,Double_t p2=0,Double_t p3=0,Double_t p4=0,
                                     Double_t p5=0,Double_t p6=0,Double_t p7=0,Double_t p8=0,
                                     Double_t p9=0,Double_t p10=0); // *MENU*
   virtual void SetParName(Int_t ipar, const char *name);
   virtual void SetParNames(const char *name0="p0",const char *name1="p1",const char
                                   *name2="p2",const char *name3="p3",const char
                                   *name4="p4", const char *name5="p5",const char *name6="p6",const char *name7="p7",const char
                                   *name8="p8",const char *name9="p9",const char *name10="p10"); // *MENU*
   virtual void Update() {;}

   static void SetMaxima(Int_t maxop=1000, Int_t maxpar=1000, Int_t maxconst=1000);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 8; } static void Dictionary(); virtual TClass *IsA() const { return TFormula::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TFormula::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFormula.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 267; } //The formula base class  f(x,y,z,par)
};
# 28 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttLine.h" 1
// @(#)root/base:$Id: TAttLine.h 27860 2009-03-18 08:36:17Z brun $
// Author: Rene Brun   28/11/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TAttLine                                                             //
//                                                                      //
// Line attributes.                                                     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttLine.h"
class TAttLine {

protected:
   Color_t fLineColor; //line color
   Style_t fLineStyle; //line style
   Width_t fLineWidth; //line width

public:

   TAttLine();
   TAttLine(Color_t lcolor,Style_t lstyle, Width_t lwidth);
   virtual ~TAttLine();

   void Copy(TAttLine &attline) const;
   Int_t DistancetoLine(Int_t px, Int_t py, Double_t xp1, Double_t yp1, Double_t xp2, Double_t yp2 );
   virtual Color_t GetLineColor() const {return fLineColor;}
   virtual Style_t GetLineStyle() const {return fLineStyle;}
   virtual Width_t GetLineWidth() const {return fLineWidth;}
   virtual void Modify();
   virtual void ResetAttLine(Option_t *option="");
   virtual void SaveLineAttributes(ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t widdef=1);
   virtual void SetLineAttributes(); // *MENU*
   virtual void SetLineColor(Color_t lcolor) { fLineColor = lcolor;}
   virtual void SetLineStyle(Style_t lstyle) { fLineStyle = lstyle;}
   virtual void SetLineWidth(Width_t lwidth) { fLineWidth = lwidth;}

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TAttLine::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TAttLine::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttLine.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 58; }; //Line attributes
};

   enum ELineStyle { kSolid = 1, kDashed, kDotted, kDashDotted };
# 31 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttFill.h" 1
// @(#)root/base:$Id: TAttFill.h 27860 2009-03-18 08:36:17Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TAttFill                                                             //
//                                                                      //
// Fill area attributes.                                                //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttFill.h"
class TAttFill {

protected:
   Color_t fFillColor; //fill area color
   Style_t fFillStyle; //fill area style

public:
   TAttFill();
   TAttFill(Color_t fcolor,Style_t fstyle);
   virtual ~TAttFill();
   void Copy(TAttFill &attfill) const;
   virtual Color_t GetFillColor() const { return fFillColor; }
   virtual Style_t GetFillStyle() const { return fFillStyle; }
   virtual Bool_t IsTransparent() const;
   virtual void Modify();
   virtual void ResetAttFill(Option_t *option="");
   virtual void SaveFillAttributes(ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1001);
   virtual void SetFillAttributes(); // *MENU*
   virtual void SetFillColor(Color_t fcolor) { fFillColor = fcolor; }
   virtual void SetFillStyle(Style_t fstyle) { fFillStyle = fstyle; }

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TAttFill::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TAttFill::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttFill.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 53; } //Fill area attributes
};

inline Bool_t TAttFill::IsTransparent() const
{ return fFillStyle >= 4000 && fFillStyle <= 4100 ? kTRUE : kFALSE; }
# 34 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttMarker.h" 1
// @(#)root/base:$Id: TAttMarker.h 38648 2011-03-29 08:02:56Z couet $
// Author: Rene Brun   12/05/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TAttMarker                                                           //
//                                                                      //
// Marker attributes.                                                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttMarker.h"
class TAttMarker {

protected:
   Color_t fMarkerColor; //Marker color index
   Style_t fMarkerStyle; //Marker style
   Size_t fMarkerSize; //Marker size

public:
   TAttMarker();
   TAttMarker(Color_t color, Style_t style, Size_t msize);
   virtual ~TAttMarker();
           void Copy(TAttMarker &attmarker) const;
   virtual Color_t GetMarkerColor() const {return fMarkerColor;}
   virtual Style_t GetMarkerStyle() const {return fMarkerStyle;}
   virtual Size_t GetMarkerSize() const {return fMarkerSize;}
   virtual void Modify();
   virtual void ResetAttMarker(Option_t *toption="");
   virtual void SaveMarkerAttributes(ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t sizdef=1);
   virtual void SetMarkerAttributes(); // *MENU*
   virtual void SetMarkerColor(Color_t tcolor=1) { fMarkerColor = tcolor;}
   virtual void SetMarkerStyle(Style_t mstyle=1) { fMarkerStyle = mstyle;}
   virtual void SetMarkerSize(Size_t msize=1) { fMarkerSize = msize;}

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TAttMarker::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TAttMarker::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttMarker.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 55; }; //Marker attributes
};

   enum EMarkerStyle {kDot=1, kPlus, kStar, kCircle=4, kMultiply=5,
                      kFullDotSmall=6, kFullDotMedium=7, kFullDotLarge=8,
                      kFullCircle=20, kFullSquare=21, kFullTriangleUp=22,
                      kFullTriangleDown=23, kOpenCircle=24, kOpenSquare=25,
                      kOpenTriangleUp=26, kOpenDiamond=27, kOpenCross=28,
                      kFullStar=29, kOpenStar=30, kOpenTriangleDown=32,
                      kFullDiamond=33, kFullCross=34};
# 37 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h" 2



# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Math/ParamFunctor.h" 1
// @(#)root/mathcore:$Id: ParamFunctor.h 26722 2008-12-08 10:35:18Z moneta $
// Author: L. Moneta Mon Nov 13 15:58:13 2006

/**********************************************************************
 *                                                                    *
 * Copyright (c) 2006  LCG ROOT Math Team, CERN/PH-SFT                *
 *                                                                    *
 *                                                                    *
 **********************************************************************/

// Header file for Functor classes. 
// design is inspired by the Loki Functor




// #ifndef ROOT_Math_IFunction
// #include "Math/IFunction.h"
// #endif

// #ifndef Root_Math_StaticCheck
// #include "Math/StaticCheck.h"
// #endif

//#ifndef __CINT__
//#include <memory> 

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/vector" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_vector" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <vector.dll>
#pragma include_noerr <vectorbool.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/vector

#pragma ifndef PREC_STL_VECTOR
#pragma define PREC_STL_VECTOR
#pragma link off global PREC_STL_VECTOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from ANSI/ISO C++ 1997/Nov draft 
// Got some ideas from Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <iterator.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/iterator

#pragma ifndef PREC_STL_ITERATOR
#pragma define PREC_STL_ITERATOR
#pragma link off global PREC_STL_ITERATOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from STL HP implementation 1994
// Imported from STL SGI implementation 1997 
// Imported from ANSI/ISO C++ draft Nov 1997
// Modified by Masaharu Goto
// May need improvement for the latest standard


////////////////////////////////////////////////////////////////////////
// iterator_tag
////////////////////////////////////////////////////////////////////////
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag {};
struct bidirectional_iterator_tag {};
struct random_access_iterator_tag {};

////////////////////////////////////////////////////////////////////////
// iterator template
////////////////////////////////////////////////////////////////////////
template <class T, class Distance> struct input_iterator {};
struct output_iterator {};
template <class T, class Distance> struct forward_iterator {};
template <class T, class Distance> struct bidirectional_iterator {};
template <class T, class Distance> struct random_access_iterator {};

#pragma link off class output_iterator;







////////////////////////////////////////////////////////////////////////
// iterator_category overloaded function
////////////////////////////////////////////////////////////////////////
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const input_iterator<T, Distance>&) {
    return input_iterator_tag();
}

inline output_iterator_tag iterator_category(const output_iterator&) {
    return output_iterator_tag();
}

#pragma link off function iterator_category(const output_iterator&);


template <class T, class Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<T, Distance>&) {
    return forward_iterator_tag();
}

template <class T, class Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<T, Distance>&) {
    return bidirectional_iterator_tag();
}

template <class T, class Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<T, Distance>&) {
    return random_access_iterator_tag();
}

template <class T>
inline random_access_iterator_tag
iterator_category(const T*) {
    return random_access_iterator_tag();
}


// iterator_traits, iterator and reverse_iterator template may not be
// needed for precompiled library interface 

////////////////////////////////////////////////////////////////////////
// iterator_traits
////////////////////////////////////////////////////////////////////////

template <class Iterator>
struct iterator_traits {
  typedef typename Iterator::iterator_category iterator_category;
  typedef typename Iterator::value_type value_type;
  typedef typename Iterator::difference_type difference_type;
  typedef typename Iterator::pointer pointer;
  typedef typename Iterator::reference reference;
};

// template partial specialization, implement in cint5.15.14 1587
template <class T>
struct iterator_traits<T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef T& reference;
};

// incomplete implementation in cint5.15.14 1587, need some fix
// iterator_traits<const int*> is changed as iterator_traits<const int* const>
// or something, but cint5.15.14 can not handle this well
template <class T>
struct iterator_traits<const T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef const T* pointer;
  typedef const T& reference;
};

////////////////////////////////////////////////////////////////////////
// iterator
////////////////////////////////////////////////////////////////////////
template<class Category, class T, class Distance = ptrdiff_t,
         class Pointer = T*, class Reference = T&>
struct iterator {
  typedef T value_type;
  typedef Distance difference_type;
  typedef Pointer pointer;
  typedef Reference reference;
  typedef Category iterator_category;
};


////////////////////////////////////////////////////////////////////////
// reverse_iterator
////////////////////////////////////////////////////////////////////////






template <class Iterator>
class reverse_iterator
# 166 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
{




 public:
# 181 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
   typedef Iterator::pointer pointer;
   typedef Iterator::reference reference;
   typedef ptrdiff_t difference_type;


   reverse_iterator();
   //reverse_iterator(Iterator x);



   Iterator base() const; // explicit
   reference operator*() const;
   pointer operator->() const;
   reverse_iterator& operator++();
   reverse_iterator operator++(int);
   reverse_iterator& operator--();
   reverse_iterator operator--(int);
   reverse_iterator operator+ (difference_type n) const;
   reverse_iterator& operator+=(difference_type n);
   reverse_iterator operator- (difference_type n) const;
   reverse_iterator& operator-=(difference_type n);
   reference operator[](difference_type n) const;
};
# 932 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
// for g++ 3.1,3.2
namespace __gnu_cxx
{
  // This iterator adapter is 'normal' in the sense that it does not
  // change the semantics of any of the operators of its iterator
  // parameter.  Its primary purpose is to convert an iterator that is
  // not a class, e.g. a pointer, into an iterator that is a class.
  // The _Container parameter exists solely so that different containers
  // using this template can instantiate different types, even if the
  // _Iterator parameter is the same.
  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
      : public iterator<typename iterator_traits<_Iterator>::iterator_category,
                        typename iterator_traits<_Iterator>::value_type,
                        typename iterator_traits<_Iterator>::difference_type,
                        typename iterator_traits<_Iterator>::pointer,
                        typename iterator_traits<_Iterator>::reference>
    {
    protected:
      _Iterator _M_current;

    public:
      typedef typename iterator_traits<_Iterator>::difference_type
                    difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

      __normal_iterator() : _M_current(_Iterator()) { }

      explicit
      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

      // Allow iterator to const_iterator conversion
      template<typename _Iter>
      inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
 : _M_current(__i.base()) { }

      // Forward iterator requirements
      reference
      operator*() const { return *_M_current; }

      pointer
      operator->() const { return _M_current; }

      __normal_iterator&
      operator++() { ++_M_current; return *this; }

      __normal_iterator
      operator++(int) { return __normal_iterator(_M_current++); }

      // Bidirectional iterator requirements
      __normal_iterator&
      operator--() { --_M_current; return *this; }

      __normal_iterator
      operator--(int) { return __normal_iterator(_M_current--); }

      // Random access iterator requirements
      reference
      operator[](const difference_type& __n) const
      { return _M_current[__n]; }

      __normal_iterator&
      operator+=(const difference_type& __n)
      { _M_current += __n; return *this; }

      __normal_iterator
      operator+(const difference_type& __n) const
      { return __normal_iterator(_M_current + __n); }

      __normal_iterator&
      operator-=(const difference_type& __n)
      { _M_current -= __n; return *this; }

      __normal_iterator
      operator-(const difference_type& __n) const
      { return __normal_iterator(_M_current - __n); }

      const _Iterator&
      base() const { return _M_current; }
    };

  // Note: In what follows, the left- and right-hand-side iterators are
  // allowed to vary in types (conceptually in cv-qualification) so that
  // comparaison between cv-qualified and non-cv-qualified iterators be
  // valid.  However, the greedy and unfriendly operators in std::rel_ops
  // will make overload resolution ambiguous (when in scope) if we don't
  // provide overloads whose operands are of the same type.  Can someone
  // remind me what generic programming is about? -- Gaby

  // Forward iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  // Random access iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  // _GLIBCPP_RESOLVE_LIB_DEFECTS
  // According to the resolution of DR179 not only the various comparison
  // operators but also operator- must accept mixed iterator/const_iterator
  // parameters.
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
     const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
} // namespace __gnu_cxx







#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 2
# 27 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_memory" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <memory.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/memory

#pragma ifndef PREC_STL_MEMORY
#pragma define PREC_STL_MEMORY
#pragma link off global PREC_STL_MEMORY;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

// Implemented by Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab
# 27 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
//////////////////////////////////////////////////////////////////////


template <class _Tp>
class allocator {
  //typedef alloc _Alloc;          // The underlying allocator.
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef typename _Tp* pointer;
  typedef const typename _Tp * const_pointer;




  typedef _Tp& reference;
  typedef const _Tp& const_reference;
  typedef _Tp value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };

  allocator() ;
  allocator(const allocator&) ;
  //template <class _Tp1> allocator(const allocator<_Tp1>&) ;
  ~allocator() ;

  pointer address(reference __x) const ;
  const_pointer address(const_reference __x) const ;

  // __n is permitted to be 0.  The C++ standard says nothing about what
  // the return value is when __n == 0.
  _Tp* allocate(size_type __n, const void* = 0) ;

  // __p is not permitted to be a null pointer.
  void deallocate(pointer __p, size_type __n);

  size_type max_size() const ;

  void construct(pointer __p, const _Tp& __val) ;
  void destroy(pointer __p) ;
};

template<>
class allocator<void> {
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef void* pointer;
  typedef const void* const_pointer;
  typedef void value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };
};
//////////////////////////////////////////////////////////////////////
# 205 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
//////////////////////////////////////////////////////////////////////

/**********************************************************************
* auto_ptr
**********************************************************************/
template <class X> class auto_ptr {
private:
  X* ptr;
  //template<class Y> struct auto_ptr_ref { };
public:
  typedef X element_type;
  explicit auto_ptr(X* p = 0) : ptr(p) {}
  auto_ptr(auto_ptr& a) {ptr=a.ptr;}

  // this implementation may not be correct
  template <class T> auto_ptr(auto_ptr<T>& a) {ptr=a.release();}
# 229 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
  auto_ptr& operator=(auto_ptr& a) {
    if (a.ptr != ptr) {
      delete ptr;
      ptr = a.ptr;
    }
    return(*this);
  }

  // this implementation may not be correct
  template <class T> auto_ptr& operator=(auto_ptr<T>& a) {
    if (a.ptr != ptr) {
       delete ptr;
       ptr = a.release();
    }
    return(*this);
  }

  ~auto_ptr() { delete ptr; }

  X& operator*() const { return *ptr; }
  X* operator->() const { return ptr; }
  X* get() const { return ptr; }
  X* release() { X *old = ptr; ptr = 0; return 0; }
# 262 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
  // auto_ptr conversions
  //auto_ptr(auto_ptr_ref<X>& x) { }
  //template<class Y> operator auto_ptr_ref<Y>() { return auto_ptr_ref<Y>(); }
  //template<class Y> operator auto_ptr<Y>() { return auto_ptr<T>(); }
};

#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_memory" 2
# 28 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_utility" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <utility.dll>


#pragma include_noerr <pair.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/utility" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/utility

#pragma ifndef PREC_STL_UTILITY
#pragma define PREC_STL_UTILITY
#pragma link off global PREC_STL_UTILITY;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

template <class T1, class T2>
struct pair {
  T1 first;
  T2 second;
  pair() : first(T1()), second(T2()) {}
  pair(const T1& a, const T2& b) : first(a), second(b) {}
 private:
  pair& operator=(const pair& x){first=x.first;second=x.second;return *this;}
};

#pragma endif
# 17 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_utility" 2
# 29 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector" 2
# 37 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
template<class T,class Allocator=std::allocator<T> >
# 49 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
class vector {
 public:
  typedef T value_type;


  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
# 218 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
  class iterator {
   public:
     typedef vector::pointer pointer;
     typedef vector::const_pointer const_pointer;
     typedef vector::reference reference;
     typedef vector::const_reference const_reference;
     typedef vector::size_type size_type;
     typedef vector::difference_type difference_type;

      iterator();
      explicit iterator(const pointer& __i) ;
      // Allow iterator to const_iterator conversion
      template<typename _Iter> inline iterator(const iterator& __i);

      // Forward iterator requirements
      reference operator*() const ;
      pointer operator->() const ;
      iterator& operator++();
      iterator operator++(int) ;

      // Bidirectional iterator requirements
      iterator& operator--() ;
      iterator operator--(int) ;

      // Random access iterator requirements
      reference operator[](const difference_type& __n) const;
      iterator& operator+=(const difference_type& __n);
      iterator operator+(const difference_type& __n) const;
      iterator& operator-=(const difference_type& __n);
      iterator operator-(const difference_type& __n) const;
      const pointer& base() const ;

      iterator operator=(const iterator& x) ;

  };

  friend bool operator==(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator!=(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator<(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator>(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator<=(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator>=(const vector::iterator& x,const vector::iterator& y)const;
  friend vector::iterator::difference_type operator-(const vector::iterator& x,const vector::iterator& y)const;
  friend vector::iterator operator+(const vector::iterator::difference_type x,const vector::iterator& y)const;

  typedef const iterator const_iterator;
# 355 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator> reverse_iterator;
# 398 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
  friend bool operator==(const vector::reverse_iterator& x
                        ,const vector::reverse_iterator& y) const;
  friend bool operator!=(const vector::reverse_iterator& x
                        ,const vector::reverse_iterator& y) const;






  friend bool operator==(vector::const_iterator& x
                        ,vector::const_iterator& y) const;
  friend bool operator!=(vector::const_iterator& x
                        ,vector::const_iterator& y) const;
# 422 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
  reference at(size_type n);
  const_reference at(size_type n) const;

  iterator begin(void) ;
  iterator end(void) ;
  reverse_iterator rbegin(void) ;
  reverse_iterator rend(void) ;






  size_type size(void) const ;
  size_type max_size(void) const ;
  void resize(size_type sz) ;
  void resize(size_type sz, T c) ;
  size_type capacity(void) const ;
  bool empty(void) const ;
  reference operator[](size_type n) ;
  const_reference operator[](size_type n) const;
  vector(void) ;
  vector(size_type n,const T& value=T()) ;
  vector(const vector& x) ;
  vector(const_iterator first,const_iterator last) ;
  ~vector(void) ;
  vector& operator=(const vector& x);
  void reserve(size_type n) ;
  T& front(void) ;
  T& back(void) ;
  void push_back(const T& x) ;
  void swap(vector& x);
  iterator insert(iterator position,const T& x);
  void insert(iterator position,const_iterator first,const_iterator last);
  void insert(iterator position,size_type n,const T& x);
  void pop_back(void) ;
  void erase(iterator position) ;
  void erase(iterator first,iterator last) ;
  void clear() ;


  friend bool operator==(const vector& x, const vector& y);
  friend bool operator< (const vector& x, const vector& y);
  friend bool operator!=(const vector& x, const vector& y);
  friend bool operator> (const vector& x, const vector& y);
  friend bool operator>=(const vector& x, const vector& y);
  friend bool operator<=(const vector& x, const vector& y);



  // specialized algorithms:






#pragma ifndef G__NOALGORITHM

  // Generic algorithm


  // input iter
  friend vector::iterator
    find(vector::iterator first,vector::iterator last,const T& value);
  // forward iter
  friend vector::iterator
    find_end(vector::iterator first1,vector::iterator last1,
      vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    find_first_of(vector::iterator first1,vector::iterator last1,
           vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    adjacent_find(vector::iterator first,vector::iterator last);
  // input iter

  friend vector::difference_type
    count(vector::iterator first,vector::iterator last,const T& value);






  friend bool
    equal(vector::iterator first1,vector::iterator last1,
          vector::iterator first2);
  // forward iter
  friend vector::iterator
    search(vector::iterator first1,vector::iterator last1,
           vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    search_n(vector::iterator first,vector::iterator last
             ,vector::size_type count,const T& value);
  // input and output iter -> forward iter
  friend vector::iterator
    copy(vector::iterator first,vector::iterator last,
         vector::iterator result);
  // bidirectional iter
  friend vector::iterator
    copy_backward(vector::iterator first,vector::iterator last,
                  vector::iterator result);
  // just value_type
  friend void swap(T& a,T& b);
  // forward iter
  friend vector::iterator
    swap_ranges(vector::iterator first1,vector::iterator last1,
                vector::iterator first2);
  friend void iter_swap(vector::iterator a,vector::iterator b);
  friend void replace(vector::iterator first,vector::iterator last,
                      const T& old_value,const T& new_value);
  // input, output iter -> forward iter
  friend vector::iterator
    replace_copy(vector::iterator first,vector::iterator last,
                 vector::iterator result,
                 const T& old_value,const T& new_value);
  // forward iter
  friend void
    fill(vector::iterator first,vector::iterator last,const T& value);

  friend void
    fill_n(vector::iterator first,vector::size_type n,const T& value);

  friend vector::iterator
    remove(vector::iterator first,vector::iterator last,const T& value);
  // input,output iter -> forward iter
  friend vector::iterator
    remove_copy(vector::iterator first,vector::iterator last,
                vector::iterator result,const T& value);
  friend vector::iterator
    unique(vector::iterator first,vector::iterator last);
  friend vector::iterator
    unique_copy(vector::iterator first,vector::iterator last,
                vector::iterator result);
  friend void reverse(vector::iterator first,vector::iterator last);
  friend vector::iterator
     reverse_copy(vector::iterator first,vector::iterator last,
                  vector::iterator result);
  // forward iter

  friend void rotate(vector::iterator first,vector::iterator mid,
                     vector::iterator last);

  // forward iter
  friend vector::iterator
    rotate_copy(vector::iterator first,vector::iterator mid,
                vector::iterator last,vector::iterator result);
  // randomaccess iter
  friend void random_shuffle(vector::iterator first,vector::iterator last);
  // randomaccess iter
  friend void sort(vector::iterator first,vector::iterator last);
  friend void stable_sort(vector::iterator first,vector::iterator last);
  friend void partial_sort(vector::iterator first,vector::iterator mid,
                           vector::iterator last);
  friend vector::iterator
    partial_sort_copy(vector::iterator first,vector::iterator last,
                      vector::iterator result_first,
                      vector::iterator result_last);
  friend void nth_element(vector::iterator first,vector::iterator nth,
                          vector::iterator last);
  // forward iter
  friend vector::iterator
    lower_bound(vector::iterator first,vector::iterator last,const T& value);
  friend vector::iterator
    upper_bound(vector::iterator first,vector::iterator last,const T& value);




  friend bool binary_search(vector::iterator first,vector::iterator last,
                            const T& value);
  friend vector::iterator merge(vector::iterator first1,vector::iterator last1,
                                vector::iterator first2,vector::iterator last2,
                                vector::iterator result);
  friend void inplace_merge(vector::iterator first,vector::iterator middle,
                            vector::iterator last);
  friend bool includes(vector::iterator first1,vector::iterator last1,
                       vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    set_union(vector::iterator first1,vector::iterator last1,
              vector::iterator first2,vector::iterator last2,
              vector::iterator result);
  friend vector::iterator
    set_intersection(vector::iterator first1,vector::iterator last1,
                     vector::iterator first2,vector::iterator last2,
                     vector::iterator result);
  friend vector::iterator
    set_difference(vector::iterator first1,vector::iterator last1,
                   vector::iterator first2,vector::iterator last2,
                   vector::iterator result);
  friend vector::iterator
    set_symmetric_difference(vector::iterator first1,vector::iterator last1,
                             vector::iterator first2,vector::iterator last2,
                             vector::iterator result);
  // random access
  friend void push_heap(vector::iterator first,vector::iterator last);
  friend void pop_heap(vector::iterator first,vector::iterator last);
  friend void make_heap(vector::iterator first,vector::iterator last);
  friend void sort_heap(vector::iterator first,vector::iterator last);
  // min,max, just value_type
  friend const T& min(const T& a,const T& b);
  friend const T& max(const T& a,const T& b);
  // forward iter
  friend vector::iterator
    min_element(vector::iterator first,vector::iterator last);
  friend vector::iterator
    max_element(vector::iterator first,vector::iterator last);
  // input iter
  friend bool
    lexicographical_compare(vector::iterator first1,vector::iterator last1,
                            vector::iterator first2,vector::iterator last2);
  // bidirectional iter
  friend bool next_permutation(vector::iterator first,vector::iterator last);
  friend bool prev_permutation(vector::iterator first,vector::iterator last);
# 662 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
#pragma endif

  // iterator_category resolution
  //friend random_access_iterator_tag iterator_category(vector::iterator x);

};
# 837 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
#pragma endif
# 15 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_vector" 2
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/vector" 2
}
# 29 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Math/ParamFunctor.h" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * I/O stream header file iostream.h
 ************************************************************************
 * Description:
 *  CINT iostream header file
 ************************************************************************
 * Copyright(c) 1995~1999  Masaharu Goto 
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
# 11 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream" 2
}
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/_iostream" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// include/_iostream

std::ostream& operator<<(std::ostream& ostr,std::G__CINT_ENDL& i)
 {return(std::endl(ostr));}
std::ostream& operator<<(std::ostream& ostr,std::G__CINT_ENDS& i)
 {return(std::ends(ostr));}
std::ostream& operator<<(std::ostream& ostr,std::G__CINT_FLUSH& i)
 {return(std::flush(ostr));}

std::istream& operator>>(std::istream& istr,std::G__CINT_ws& i)
 {return(std::ws(istr));}
std::istream& operator>>(std::istream& istr,std::G__CINT_WS& i)
 {return(std::WS(istr));}


std::ostream& operator<<(std::ostream& ostr,std::G__CINT_IOFLAGS& f) {
   ostr.setf(f.flag, f.mask);
  return ostr;
}
std::istream& operator>>(std::istream& istr,std::G__CINT_IOFLAGS& f) {
  istr.setf(f.flag, f.mask);
  return istr;
}

std::ostream& operator<<(std::ostream& ostr,std::G__CINT_NOSUPPORT& i) {
  fprintf(stderr,"Limitation: dec,hex,oct manipurator not supported\n");
  return(ostr);
}
std::istream& operator<<(std::istream& istr,std::G__CINT_NOSUPPORT& i) {
  fprintf(stderr,"Limitation: dec,hex,oct manipurator not supported\n");
  return(istr);
}


std::ostream& operator<<(std::ostream& ostr,long long i) {
  char buf[200];
#pragma ifndef G__TMPLTIOS
  if (ostr.flags() & ios::hex)
#pragma else
  if (ostr.flags() & ios_base::hex)
#pragma endif
     sprintf(buf,"%llx",i);
  else
     sprintf(buf,"%lld",i);
  ostr << buf ;
  return(ostr);
}
std::ostream& operator<<(std::ostream& ostr,unsigned long long i) {
  char buf[200];
#pragma ifndef G__TMPLTIOS
  if (ostr.flags() & ios::hex)
#pragma else
  if (ostr.flags() & ios_base::hex)
#pragma endif
     sprintf(buf,"%llx",i);
  else
     sprintf(buf,"%llu",i);
  ostr << buf ;
  return(ostr);
}
std::ostream& operator<<(std::ostream& ostr,long double i) {
  char buf[200];
  sprintf(buf,"%Lg",i);
  ostr << buf ;
  return(ostr);
}
std::istream& operator>>(std::istream& istr,long long &i) {
  char buf[200];
  istr >> buf ;
  sscanf(buf,"%lld",&i);
  return(istr);
}
std::istream& operator>>(std::istream& istr,unsigned long long &i) {
  char buf[200];
  istr >> buf ;
#pragma ifndef G__TMPLTIOS
  if (ostr.flags() & ios::hex)
#pragma else
  if (ostr.flags() & ios_base::hex)
#pragma endif
     sscanf(buf,"%llx",&i);
  else
     sscanf(buf,"%llu",&i);
  return(istr);
}
std::istream& operator>>(std::istream& istr,long double &i) {
  char buf[200];
  istr >> buf ;
  sscanf(buf,"%Lg",&i);
  return(istr);
}


// Value evaluation
//template<class T> int G__ateval(const T* x) {return(0);}
//template<class T> int G__ateval(const T& x) {return(0);}
int G__ateval(const char* const &x) {return(0);}
//int G__ateval(const void* const &x) {return(0);}
int G__ateval(double x) {return(0);}
int G__ateval(float x) {return(0);}
int G__ateval(bool x) {return(0);}
int G__ateval(char x) {return(0);}
int G__ateval(short x) {return(0);}
int G__ateval(int x) {return(0);}
int G__ateval(long x) {return(0);}
int G__ateval(unsigned char x) {return(0);}
int G__ateval(unsigned short x) {return(0);}
int G__ateval(unsigned int x) {return(0);}
int G__ateval(unsigned long x) {return(0);}
# 127 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/_iostream"
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iomanip.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * I/O manipulator header for iomanip.h
 ************************************************************************
 * Description:
 *  CINT IOMANIP header file
 ************************************************************************
 * Author                  Masaharu Goto 
 * Copyright(c) 1995~1999  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
# 127 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/_iostream" 2
# 12 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iostream" 2
# 30 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Math/ParamFunctor.h" 2

namespace ROOT {

namespace Math {


/** class defining the signature for multi-dim parametric functions 

   @ingroup  ParamFunctor_int
 */

class ParamFunctionBase {
  public:
   virtual ~ParamFunctionBase() {}
//   virtual double operator() (const double * x, const double *p) const = 0; 
   virtual double operator() (double * x, double *p) = 0;
   virtual ParamFunctionBase * Clone() const = 0;
};



/** 
   ParamFunctor Handler class is responsible for wrapping any other functor and pointer to 
   free C functions.
   It can be created from any function implementing the correct signature 
   corresponding to the requested type

   @ingroup  ParamFunctor_int

*/
# 197 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Math/ParamFunctor.h"
/**
   Param Functor class for Multidimensional functions. 
   It is used to wrap in a very simple and convenient way 
   any other C++ callable object (implemention double operator( const double *, const double * ) ) 
   or a member function with the correct signature, 
   like Foo::EvalPar(const double *, const double *)

   @ingroup  ParamFunc

 */


class ParamFunctor {


public:

   typedef ParamFunctionBase Impl;


   /** 
      Default constructor
   */
   ParamFunctor () : fImpl(0) {}


   /** 
       construct from a pointer to member function (multi-dim type)
    */
   template <class PtrObj, typename MemFn>
   ParamFunctor(const PtrObj& p, MemFn memFn)
      : fImpl(new ParamMemFunHandler<ParamFunctor, PtrObj, MemFn>(p, memFn))
   {}



   /**
      construct from another generic Functor of multi-dimension 
    */
   template <typename Func>
   explicit ParamFunctor( const Func & f) :
      fImpl(new ParamFunctorHandler<ParamFunctor,Func>(f) )
   {}



   // specialization used in TF1
   typedef double (* FreeFunc ) (double * , double *);
   ParamFunctor(FreeFunc f) :
      fImpl(new ParamFunctorHandler<ParamFunctor,FreeFunc>(f) )
   {
   }


   /** 
      Destructor (no operations)
   */
   virtual ~ParamFunctor () {
      if (fImpl) delete fImpl;
   }

   /** 
      Copy constructor
   */
   ParamFunctor(const ParamFunctor & rhs) :
      fImpl(0)
   {
//       if (rhs.fImpl.get() != 0) 
//          fImpl = std::auto_ptr<Impl>( (rhs.fImpl)->Clone() ); 
      if (rhs.fImpl != 0) fImpl = rhs.fImpl->Clone();
   }

   /** 
      Assignment operator
   */
   ParamFunctor & operator = (const ParamFunctor & rhs) {
//      ParamFunctor copy(rhs); 
      // swap auto_ptr by hand
//       Impl * p = fImpl.release(); 
//       fImpl.reset(copy.fImpl.release());
//       copy.fImpl.reset(p);


      if (fImpl) delete fImpl;
      fImpl = 0;
      if (rhs.fImpl != 0)
         fImpl = rhs.fImpl->Clone();

      return *this;
   }

   void * GetImpl() { return (void *) fImpl; }


   double operator() (double * x, double * p) {
      return (*fImpl)(x,p);
   }



   bool Empty() { return fImpl == 0; }


   void SetFunction(Impl * f) {
      fImpl = f;
   }

private :


   //std::auto_ptr<Impl> fImpl; 
   Impl * fImpl;


};



   } // end namespace Math

} // end namespace ROOT
# 41 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h" 2


class TF1;
class TH1;
class TAxis;
class TMethodCall;

namespace ROOT {
   namespace Fit {
      class FitResult;
   }
}

class TF1 : public TFormula, public TAttLine, public TAttFill, public TAttMarker {

protected:
   Double_t fXmin; //Lower bounds for the range
   Double_t fXmax; //Upper bounds for the range
   Int_t fNpx; //Number of points used for the graphical representation
   Int_t fType; //(=0 for standard functions, 1 if pointer to function)
   Int_t fNpfits; //Number of points used in the fit
   Int_t fNDF; //Number of degrees of freedom in the fit
   Int_t fNsave; //Number of points used to fill array fSave
   Double_t fChisquare; //Function fit chisquare
   Double_t *fIntegral; //![fNpx] Integral of function binned on fNpx bins
   Double_t *fParErrors; //[fNpar] Array of errors of the fNpar parameters
   Double_t *fParMin; //[fNpar] Array of lower limits of the fNpar parameters
   Double_t *fParMax; //[fNpar] Array of upper limits of the fNpar parameters
   Double_t *fSave; //[fNsave] Array of fNsave function values
   Double_t *fAlpha; //!Array alpha. for each bin in x the deconvolution r of fIntegral
   Double_t *fBeta; //!Array beta.  is approximated by x = alpha +beta*r *gamma*r**2
   Double_t *fGamma; //!Array gamma.
   TObject *fParent; //!Parent object hooking this function (if one)
   TH1 *fHistogram; //!Pointer to histogram used for visualisation
   Double_t fMaximum; //Maximum value for plotting
   Double_t fMinimum; //Minimum value for plotting
   TMethodCall *fMethodCall; //!Pointer to MethodCall in case of interpreted function
   void *fCintFunc; //! pointer to interpreted function class
   ROOT::Math::ParamFunctor fFunctor; //! Functor object to wrap any C++ callable object

   static Bool_t fgAbsValue; //use absolute value of function when computing integral
   static Bool_t fgRejectPoint; //True if point must be rejected in a fit
   static TF1 *fgCurrent; //pointer to current function being processed

   void CreateFromFunctor(const char *name, Int_t npar);
   void CreateFromCintClass(const char *name, void * ptr, Double_t xmin, Double_t xmax, Int_t npar, const char * cname, const char * fname);

public:
    // TF1 status bits
    enum {
       kNotDraw = (1ULL << (9)) // don't draw the function when in a TH1
    };

   TF1();
   TF1(const char *name, const char *formula, Double_t xmin=0, Double_t xmax=1);
   TF1(const char *name, Double_t xmin, Double_t xmax, Int_t npar);
   TF1(const char *name, void *fcn, Double_t xmin, Double_t xmax, Int_t npar);





   // Constructors using functors (compiled mode only)
   TF1(const char *name, ROOT::Math::ParamFunctor f, Double_t xmin = 0, Double_t xmax = 1, Int_t npar = 0);

   // Template constructors from any  C++ callable object,  defining  the operator() (double * , double *)
   // and returning a double.
   // The class name is not needed when using compile code, while it is required when using
   // interpreted code via the specialized constructor with void *.
   // An instance of the C++ function class or its pointer can both be used. The former is reccomended when using
   // C++ compiled code, but if CINT compatibility is needed, then a pointer to the function class must be used.
   // xmin and xmax specify the plotting range,  npar is the number of parameters.
   // See the tutorial math/exampleFunctor.C for an example of using this constructor
   template <typename Func>
   TF1(const char *name, Func f, Double_t xmin, Double_t xmax, Int_t npar, const char * = 0 ) :
      TFormula(),
      TAttLine(),
      TAttFill(),
      TAttMarker(),
      fXmin ( xmin ),
      fXmax ( xmax ),
      fNpx ( 100 ),
      fType ( 1 ),
      fNpfits ( 0 ),
      fNDF ( 0 ),
      fNsave ( 0 ),
      fChisquare ( 0 ),
      fIntegral ( 0 ),
      fParErrors ( 0 ),
      fParMin ( 0 ),
      fParMax ( 0 ),
      fSave ( 0 ),
      fAlpha ( 0 ),
      fBeta ( 0 ),
      fGamma ( 0 ),
      fParent ( 0 ),
      fHistogram ( 0 ),
      fMaximum ( -1111 ),
      fMinimum ( -1111 ),
      fMethodCall ( 0),
      fCintFunc ( 0 ),
      fFunctor( ROOT::Math::ParamFunctor(f) )
   {
      CreateFromFunctor(name, npar);
   }

   // Template constructors from a pointer to any C++ class of type PtrObj with a specific member function of type
   // MemFn.
   // The member function must have the signature of  (double * , double *) and returning a double.
   // The class name and the method name are not needed when using compile code
   // (the member function pointer is used in this case), while they are required when using interpreted
   // code via the specialized constructor with void *.
   // xmin and xmax specify the plotting range,  npar is the number of parameters.
   // See the tutorial math/exampleFunctor.C for an example of using this constructor
   template <class PtrObj, typename MemFn>
   TF1(const char *name, const PtrObj& p, MemFn memFn, Double_t xmin, Double_t xmax, Int_t npar, const char * = 0, const char * = 0) :
      TFormula(),
      TAttLine(),
      TAttFill(),
      TAttMarker(),
      fXmin ( xmin ),
      fXmax ( xmax ),
      fNpx ( 100 ),
      fType ( 1 ),
      fNpfits ( 0 ),
      fNDF ( 0 ),
      fNsave ( 0 ),
      fChisquare ( 0 ),
      fIntegral ( 0 ),
      fParErrors ( 0 ),
      fParMin ( 0 ),
      fParMax ( 0 ),
      fSave ( 0 ),
      fAlpha ( 0 ),
      fBeta ( 0 ),
      fGamma ( 0 ),
      fParent ( 0 ),
      fHistogram ( 0 ),
      fMaximum ( -1111 ),
      fMinimum ( -1111 ),
      fMethodCall( 0 ),
      fCintFunc ( 0 ),
      fFunctor ( ROOT::Math::ParamFunctor(p,memFn) )
   {
      CreateFromFunctor(name, npar);
   }

   // constructor used by CINT
   TF1(const char *name, void *ptr, Double_t xmin, Double_t xmax, Int_t npar, const char *className );
   TF1(const char *name, void *ptr, void *,Double_t xmin, Double_t xmax, Int_t npar, const char *className, const char *methodName = 0);

   TF1(const TF1 &f1);
   TF1& operator=(const TF1 &rhs);
   virtual ~TF1();
   virtual void Browse(TBrowser *b);
   virtual void Copy(TObject &f1) const;
   virtual Double_t Derivative (Double_t x, Double_t *params=0, Double_t epsilon=0.001) const;
   virtual Double_t Derivative2(Double_t x, Double_t *params=0, Double_t epsilon=0.001) const;
   virtual Double_t Derivative3(Double_t x, Double_t *params=0, Double_t epsilon=0.001) const;
   static Double_t DerivativeError();
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual void Draw(Option_t *option="");
   virtual TF1 *DrawCopy(Option_t *option="") const;
   virtual TObject *DrawDerivative(Option_t *option="al"); // *MENU*
   virtual TObject *DrawIntegral(Option_t *option="al"); // *MENU*
   virtual void DrawF1(const char *formula, Double_t xmin, Double_t xmax, Option_t *option="");
   virtual Double_t Eval(Double_t x, Double_t y=0, Double_t z=0, Double_t t=0) const;
   virtual Double_t EvalPar(const Double_t *x, const Double_t *params=0);
   // for using TF1 as a callable object (functor)
   virtual Double_t operator()(Double_t x, Double_t y=0, Double_t z = 0, Double_t t = 0) const;
   virtual Double_t operator()(const Double_t *x, const Double_t *params=0);
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   virtual void FixParameter(Int_t ipar, Double_t value);
       Double_t GetChisquare() const {return fChisquare;}
           TH1 *GetHistogram() const;
   virtual Double_t GetMaximum(Double_t xmin=0, Double_t xmax=0, Double_t epsilon = 1.E-10, Int_t maxiter = 100, Bool_t logx = false) const;
   virtual Double_t GetMinimum(Double_t xmin=0, Double_t xmax=0, Double_t epsilon = 1.E-10, Int_t maxiter = 100, Bool_t logx = false) const;
   virtual Double_t GetMaximumX(Double_t xmin=0, Double_t xmax=0, Double_t epsilon = 1.E-10, Int_t maxiter = 100, Bool_t logx = false) const;
   virtual Double_t GetMinimumX(Double_t xmin=0, Double_t xmax=0, Double_t epsilon = 1.E-10, Int_t maxiter = 100, Bool_t logx = false) const;
   virtual Int_t GetNDF() const;
   virtual Int_t GetNpx() const {return fNpx;}
    TMethodCall *GetMethodCall() const {return fMethodCall;}
   virtual Int_t GetNumberFreeParameters() const;
   virtual Int_t GetNumberFitPoints() const {return fNpfits;}
   virtual char *GetObjectInfo(Int_t px, Int_t py) const;
        TObject *GetParent() const {return fParent;}
   virtual Double_t GetParError(Int_t ipar) const;
   virtual Double_t *GetParErrors() const {return fParErrors;}
   virtual void GetParLimits(Int_t ipar, Double_t &parmin, Double_t &parmax) const;
   virtual Double_t GetProb() const;
   virtual Int_t GetQuantiles(Int_t nprobSum, Double_t *q, const Double_t *probSum);
   virtual Double_t GetRandom();
   virtual Double_t GetRandom(Double_t xmin, Double_t xmax);
   virtual void GetRange(Double_t &xmin, Double_t &xmax) const;
   virtual void GetRange(Double_t &xmin, Double_t &ymin, Double_t &xmax, Double_t &ymax) const;
   virtual void GetRange(Double_t &xmin, Double_t &ymin, Double_t &zmin, Double_t &xmax, Double_t &ymax, Double_t &zmax) const;
   virtual Double_t GetSave(const Double_t *x);
   virtual Double_t GetX(Double_t y, Double_t xmin=0, Double_t xmax=0, Double_t epsilon = 1.E-10, Int_t maxiter = 100, Bool_t logx = false) const;
   virtual Double_t GetXmin() const {return fXmin;}
   virtual Double_t GetXmax() const {return fXmax;}
   TAxis *GetXaxis() const ;
   TAxis *GetYaxis() const ;
   TAxis *GetZaxis() const ;
   virtual Double_t GradientPar(Int_t ipar, const Double_t *x, Double_t eps=0.01);
   virtual void GradientPar(const Double_t *x, Double_t *grad, Double_t eps=0.01);
   virtual void InitArgs(const Double_t *x, const Double_t *params);
   static void InitStandardFunctions();
   virtual Double_t Integral(Double_t a, Double_t b, const Double_t *params=0, Double_t epsilon=1e-12);
   virtual Double_t Integral(Double_t ax, Double_t bx, Double_t ay, Double_t by, Double_t epsilon=1e-12);
   virtual Double_t Integral(Double_t ax, Double_t bx, Double_t ay, Double_t by, Double_t az, Double_t bz, Double_t epsilon=1e-12);
   virtual Double_t IntegralError(Double_t a, Double_t b, const Double_t *params=0, const Double_t *covmat=0, Double_t epsilon=1e-12);
   virtual Double_t IntegralError(Int_t n, const Double_t * a, const Double_t * b, const Double_t *params=0, const Double_t *covmat=0, Double_t epsilon=1e-12);
   //virtual Double_t IntegralFast(const TGraph *g, Double_t a, Double_t b, Double_t *params=0);
   virtual Double_t IntegralFast(Int_t num, Double_t *x, Double_t *w, Double_t a, Double_t b, Double_t *params=0, Double_t epsilon=1e-12);
   virtual Double_t IntegralMultiple(Int_t n, const Double_t *a, const Double_t *b, Int_t minpts, Int_t maxpts, Double_t epsilon, Double_t &relerr,Int_t &nfnevl, Int_t &ifail);
   virtual Double_t IntegralMultiple(Int_t n, const Double_t *a, const Double_t *b, Double_t epsilon, Double_t &relerr);
   virtual Bool_t IsInside(const Double_t *x) const;
   virtual void Paint(Option_t *option="");
   virtual void Print(Option_t *option="") const;
   virtual void ReleaseParameter(Int_t ipar);
   virtual void Save(Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax, Double_t zmin, Double_t zmax);
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetChisquare(Double_t chi2) {fChisquare = chi2;}
   virtual void SetFitResult(const ROOT::Fit::FitResult & result, const Int_t * indpar = 0);
   template <class PtrObj, typename MemFn>
   void SetFunction( PtrObj& p, MemFn memFn );
   template <typename Func>
   void SetFunction( Func f );
   virtual void SetMaximum(Double_t maximum=-1111); // *MENU*
   virtual void SetMinimum(Double_t minimum=-1111); // *MENU*
   virtual void SetNDF(Int_t ndf);
   virtual void SetNumberFitPoints(Int_t npfits) {fNpfits = npfits;}
   virtual void SetNpx(Int_t npx=100); // *MENU*
   virtual void SetParError(Int_t ipar, Double_t error);
   virtual void SetParErrors(const Double_t *errors);
   virtual void SetParLimits(Int_t ipar, Double_t parmin, Double_t parmax);
   virtual void SetParent(TObject *p=0) {fParent = p;}
   virtual void SetRange(Double_t xmin, Double_t xmax); // *MENU*
   virtual void SetRange(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax);
   virtual void SetRange(Double_t xmin, Double_t ymin, Double_t zmin, Double_t xmax, Double_t ymax, Double_t zmax);
   virtual void SetSavedPoint(Int_t point, Double_t value);
   virtual void SetTitle(const char *title=""); // *MENU*
   virtual void Update();

   static TF1 *GetCurrent();
   static void AbsValue(Bool_t reject=kTRUE);
   static void RejectPoint(Bool_t reject=kTRUE);
   static Bool_t RejectedPoint();
   static void SetCurrent(TF1 *f1);

   //Moments
   virtual Double_t Moment(Double_t n, Double_t a, Double_t b, const Double_t *params=0, Double_t epsilon=0.000001);
   virtual Double_t CentralMoment(Double_t n, Double_t a, Double_t b, const Double_t *params=0, Double_t epsilon=0.000001);
   virtual Double_t Mean(Double_t a, Double_t b, const Double_t *params=0, Double_t epsilon=0.000001) {return Moment(1,a,b,params,epsilon);}
   virtual Double_t Variance(Double_t a, Double_t b, const Double_t *params=0, Double_t epsilon=0.000001) {return CentralMoment(2,a,b,params,epsilon);}

   //some useful static utility functions to compute sampling points for Integral
   //static  void     CalcGaussLegendreSamplingPoints(TGraph *g, Double_t eps=3.0e-11);
   //static  TGraph  *CalcGaussLegendreSamplingPoints(Int_t num=21, Double_t eps=3.0e-11);
   static void CalcGaussLegendreSamplingPoints(Int_t num, Double_t *x, Double_t *w, Double_t eps=3.0e-11);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 7; } static void Dictionary(); virtual TClass *IsA() const { return TF1::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TF1::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 302; } //The Parametric 1-D function
};

inline Double_t TF1::operator()(Double_t x, Double_t y, Double_t z, Double_t t) const
   { return Eval(x,y,z,t); }
inline Double_t TF1::operator()(const Double_t *x, const Double_t *params)
   {
      if (fMethodCall) InitArgs(x,params);
      return EvalPar(x,params);
   }


inline void TF1::SetRange(Double_t xmin, Double_t, Double_t xmax, Double_t)
   { TF1::SetRange(xmin, xmax); }
inline void TF1::SetRange(Double_t xmin, Double_t, Double_t, Double_t xmax, Double_t, Double_t)
   { TF1::SetRange(xmin, xmax); }

template <typename Func>
void TF1::SetFunction( Func f ) {
   // set function from a generic C++ callable object 
   fType = 1;
   fFunctor = ROOT::Math::ParamFunctor(f);
}
template <class PtrObj, typename MemFn>
void TF1::SetFunction( PtrObj& p, MemFn memFn ) {
   // set from a pointer to a member function
   fType = 1;
   fFunctor = ROOT::Math::ParamFunctor(p,memFn);
}
# 4 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 1
// @(#)root/hist:$Id: TH1.h 44121 2012-05-04 14:44:59Z moneta $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TH1                                                                  //
//                                                                      //
// 1-Dim histogram base class.                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAxis.h" 1
// @(#)root/hist:$Id: TAxis.h 43736 2012-04-13 15:16:34Z pcanal $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TAxis                                                                //
//                                                                      //
// Axis class.                                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttAxis.h" 1
// @(#)root/base:$Id: TAttAxis.h 27860 2009-03-18 08:36:17Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TAttAxis                                                             //
//                                                                      //
// Axis attributes.                                                     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttAxis.h"
class TAttAxis {
protected:
   Int_t fNdivisions; //Number of divisions(10000*n3 + 100*n2 + n1)
   Color_t fAxisColor; //color of the line axis
   Color_t fLabelColor; //color of labels
   Style_t fLabelFont; //font for labels
   Float_t fLabelOffset; //offset of labels
   Float_t fLabelSize; //size of labels
   Float_t fTickLength; //length of tick marks
   Float_t fTitleOffset; //offset of axis title
   Float_t fTitleSize; //size of axis title
   Color_t fTitleColor; //color of axis title
   Style_t fTitleFont; //font for axis title

public:
   TAttAxis();
   virtual ~TAttAxis();
   void Copy(TAttAxis &attaxis) const;
   virtual Int_t GetNdivisions() const {return fNdivisions;}
   virtual Color_t GetAxisColor() const {return fAxisColor;}
   virtual Color_t GetLabelColor() const {return fLabelColor;}
   virtual Style_t GetLabelFont() const {return fLabelFont;}
   virtual Float_t GetLabelOffset() const {return fLabelOffset;}
   virtual Float_t GetLabelSize() const {return fLabelSize;}
   virtual Float_t GetTitleOffset() const {return fTitleOffset;}
   virtual Float_t GetTitleSize() const {return fTitleSize;}
   virtual Float_t GetTickLength() const {return fTickLength;}
   virtual Color_t GetTitleColor() const {return fTitleColor;}
   virtual Style_t GetTitleFont() const {return fTitleFont;}
   virtual void ResetAttAxis(Option_t *option="");
   virtual void SaveAttributes(ostream &out, const char *name, const char *subname);
   virtual void SetNdivisions(Int_t n=510, Bool_t optim=kTRUE); // *MENU*
   virtual void SetNdivisions(Int_t n1, Int_t n2, Int_t n3, Bool_t optim=kTRUE);
   virtual void SetAxisColor(Color_t color=1); // *MENU*
   virtual void SetLabelColor(Color_t color=1); // *MENU*
   virtual void SetLabelFont(Style_t font=62); // *MENU*
   virtual void SetLabelOffset(Float_t offset=0.005); // *MENU*
   virtual void SetLabelSize(Float_t size=0.04); // *MENU*
   virtual void SetTickLength(Float_t length=0.03); // *MENU*
   virtual void SetTitleOffset(Float_t offset=1); // *MENU*
   virtual void SetTitleSize(Float_t size=0.04); // *MENU*
   virtual void SetTitleColor(Color_t color=1); // *MENU*
   virtual void SetTitleFont(Style_t font=62); // *MENU*

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 4; } static void Dictionary(); virtual TClass *IsA() const { return TAttAxis::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TAttAxis::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttAxis.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 76; }; //Axis attributes
};
# 29 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAxis.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArrayD.h" 1
// @(#)root/cont:$Id: TArrayD.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   06/03/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TArrayD                                                              //
//                                                                      //
// Array of doubles (64 bits per element).                              //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArray.h" 1
// @(#)root/cont:$Id: TArray.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Fons Rademakers   21/10/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TArray                                                               //
//                                                                      //
// Abstract array base class. Used by TArrayC, TArrayS, TArrayI,        //
// TArrayL, TArrayF and TArrayD.                                        //
// Data member is public for historical reasons.                        //
//                                                                      //
//////////////////////////////////////////////////////////////////////////




# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/string.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
/****************************************************************
* string.h
*****************************************************************/
# 30 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArray.h" 2

class TBuffer;

class TArray {

protected:
   Bool_t BoundsOk(const char *where, Int_t at) const;
   Bool_t OutOfBoundsError(const char *where, Int_t i) const;

public:
   Int_t fN; //Number of array elements

   TArray(): fN(0) { }
   TArray(Int_t n): fN(n) { }
   TArray(const TArray &a): fN(a.fN) { }
   TArray &operator=(const TArray &rhs)
     {if(this!=&rhs) fN = rhs.fN; return *this; }
   virtual ~TArray() { fN = 0; }

   Int_t GetSize() const { return fN; }
   virtual void Set(Int_t n) = 0;

   virtual Double_t GetAt(Int_t i) const = 0;
   virtual void SetAt(Double_t v, Int_t i) = 0;

   static TArray *ReadArray(TBuffer &b, const TClass *clReq);
   static void WriteArray(TBuffer &b, const TArray *a);

   friend TBuffer &operator<<(TBuffer &b, const TArray *obj);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TArray::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TArray::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArray.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 60; } //Abstract array base class
};




inline TBuffer &operator>>(TBuffer &buf, TArray *&obj)
{
   // Read TArray object from buffer.

   obj = (TArray *) TArray::ReadArray(buf, TArray::Class());
   return buf;
}




TBuffer &operator<<(TBuffer &b, const TArray *obj);

inline Bool_t TArray::BoundsOk(const char *where, Int_t at) const
{
   return (at < 0 || at >= fN)
                  ? OutOfBoundsError(where, at)
                  : kTRUE;
}
# 26 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArrayD.h" 2



class TArrayD : public TArray {

public:
   Double_t *fArray; //[fN] Array of fN doubles

   TArrayD();
   TArrayD(Int_t n);
   TArrayD(Int_t n, const Double_t *array);
   TArrayD(const TArrayD &array);
   TArrayD &operator=(const TArrayD &rhs);
   virtual ~TArrayD();

   void Adopt(Int_t n, Double_t *array);
   void AddAt(Double_t c, Int_t i);
   Double_t At(Int_t i) const ;
   void Copy(TArrayD &array) const {array.Set(fN,fArray);}
   const Double_t *GetArray() const { return fArray; }
   Double_t *GetArray() { return fArray; }
   Double_t GetAt(Int_t i) const { return At(i); }
   Stat_t GetSum() const {Stat_t sum=0; for (Int_t i=0;i<fN;i++) sum+=fArray[i]; return sum;}
   void Reset() {memset(fArray, 0, fN*sizeof(Double_t));}
   void Reset(Double_t val) {for (Int_t i=0;i<fN;i++) fArray[i] = val;}
   void Set(Int_t n);
   void Set(Int_t n, const Double_t *array);
   void SetAt(Double_t v, Int_t i) { AddAt(v, i); }
   Double_t &operator[](Int_t i);
   Double_t operator[](Int_t i) const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TArrayD::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TArrayD::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArrayD.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 57; } //Array of doubles
};





inline TBuffer &operator>>(TBuffer &buf, TArrayD *&obj)
{
   // Read TArrayD object from buffer.

   obj = (TArrayD *) TArray::ReadArray(buf, TArrayD::Class());
   return buf;
}




inline TBuffer &operator<<(TBuffer &buf, const TArrayD *obj)
{
   // Write a TArrayD object into buffer
   return buf << (TArray*)obj;
}

inline Double_t TArrayD::At(Int_t i) const
{
   if (!BoundsOk("TArrayD::At", i)) return 0;
   return fArray[i];
}

inline Double_t &TArrayD::operator[](Int_t i)
{
   if (!BoundsOk("TArrayD::operator[]", i))
      i = 0;
   return fArray[i];
}

inline Double_t TArrayD::operator[](Int_t i) const
{
   if (!BoundsOk("TArrayD::operator[]", i)) return 0;
   return fArray[i];
}
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAxis.h" 2


class THashList;

class TAxis : public TNamed, public TAttAxis {

private:
   Int_t fNbins; //Number of bins
   Double_t fXmin; //low edge of first bin
   Double_t fXmax; //upper edge of last bin
   TArrayD fXbins; //Bin edges array in X
   Int_t fFirst; //first bin to display
   Int_t fLast; //last bin to display
   UShort_t fBits2; //second bit status word
   Bool_t fTimeDisplay; //on/off displaying time values instead of numerics
   TString fTimeFormat; //Date&time format, ex: 09/12/99 12:34:00
   TObject *fParent; //!Object owning this axis
   THashList *fLabels; //List of labels

public:
   // TAxis status bits
   enum { kTickPlus = (1ULL << (9)),
          kTickMinus = (1ULL << (10)),
          kAxisRange = (1ULL << (11)),
          kCenterTitle = (1ULL << (12)),
          kCenterLabels = (1ULL << (14)), //bit 13 is used by TObject
          kRotateTitle = (1ULL << (15)),
          kPalette = (1ULL << (16)),
          kNoExponent = (1ULL << (17)),
          kLabelsHori = (1ULL << (18)),
          kLabelsVert = (1ULL << (19)),
          kLabelsDown = (1ULL << (20)),
          kLabelsUp = (1ULL << (21)),
          kIsInteger = (1ULL << (22)),
          kMoreLogLabels = (1ULL << (23)),
          kDecimals = (1ULL << (11))}; //in fBits2

   TAxis();
   TAxis(Int_t nbins, Double_t xmin, Double_t xmax);
   TAxis(Int_t nbins, const Double_t *xbins);
   TAxis(const TAxis &axis);
   virtual ~TAxis();
   TAxis& operator=(const TAxis&);

   virtual void CenterLabels(Bool_t center=kTRUE); // *TOGGLE* *GETTER=GetCenterLabels
   virtual void CenterTitle(Bool_t center=kTRUE); // *TOGGLE* *GETTER=GetCenterTitle
   const char *ChooseTimeFormat(Double_t axislength=0);
   virtual void Copy(TObject &axis) const;
   virtual void Delete(Option_t * /*option*/ ="") { }
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual TObject *DrawClone(Option_t * /*option*/ ="") const {return 0;}
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   virtual Int_t FindBin(Double_t x);
   virtual Int_t FindBin(const char *label);
   virtual Int_t FindFixBin(Double_t x) const;
   virtual Double_t GetBinCenter(Int_t bin) const;
   virtual Double_t GetBinCenterLog(Int_t bin) const;
   const char *GetBinLabel(Int_t bin) const;
   virtual Double_t GetBinLowEdge(Int_t bin) const;
   virtual Double_t GetBinUpEdge(Int_t bin) const;
   virtual Double_t GetBinWidth(Int_t bin) const;
   virtual void GetCenter(Double_t *center) const;
           Bool_t GetCenterLabels() const;
           Bool_t GetCenterTitle() const;
   THashList *GetLabels() {return fLabels;}
   virtual void GetLowEdge(Double_t *edge) const;
           Bool_t GetMoreLogLabels() const;
           Int_t GetNbins() const { return fNbins; }
           Bool_t GetNoExponent() const;
           Bool_t GetDecimals() const;
   virtual TObject *GetParent() const {return fParent;}
           Bool_t GetRotateTitle() const;
   virtual const char *GetTicks() const;
   virtual Bool_t GetTimeDisplay() const {return fTimeDisplay;}
   virtual const char *GetTimeFormat() const {return fTimeFormat.Data();}
   virtual const char *GetTimeFormatOnly() const;
   const char *GetTitle() const {return fTitle.Data();}
   const TArrayD *GetXbins() const {return &fXbins;}
           Int_t GetFirst() const;
           Int_t GetLast() const;
           Double_t GetXmin() const {return fXmin;}
           Double_t GetXmax() const {return fXmax;}
   virtual void ImportAttributes(const TAxis *axis);
   Bool_t IsVariableBinSize() const {
                         // true if axis has variable bin sizes, false otherwise
                         return (fXbins.GetSize() != 0);
                      }
   virtual void LabelsOption(Option_t *option="h"); // *MENU*
   virtual void RotateTitle(Bool_t rotate=kTRUE); // *TOGGLE* *GETTER=GetRotateTitle
   virtual void SaveAttributes(ostream &out, const char *name, const char *subname);
   virtual void Set(Int_t nbins, Double_t xmin, Double_t xmax);
   virtual void Set(Int_t nbins, const Float_t *xbins);
   virtual void Set(Int_t nbins, const Double_t *xbins);
   virtual void SetBinLabel(Int_t bin, const char *label);
   virtual void SetDefaults();
   virtual void SetDrawOption(Option_t * /*option*/ ="") { }
   virtual void SetLimits(Double_t xmin, Double_t xmax);
   virtual void SetMoreLogLabels(Bool_t more=kTRUE); // *TOGGLE* *GETTER=GetMoreLogLabels
   virtual void SetNoExponent(Bool_t noExponent=kTRUE); // *TOGGLE* *GETTER=GetNoExponent
   virtual void SetDecimals(Bool_t dot=kTRUE); // *TOGGLE* *GETTER=GetDecimals
   virtual void SetParent(TObject *obj) {fParent = obj;}
   virtual void SetRange(Int_t first=0, Int_t last=0); // *MENU*
   virtual void SetRangeUser(Double_t ufirst, Double_t ulast); // *MENU*
   virtual void SetTicks(Option_t *option="+"); // *MENU*
   virtual void SetTimeDisplay(Int_t value) {fTimeDisplay = (value != 0);} // *TOGGLE*
   virtual void SetTimeFormat(const char *format=""); // *MENU*
   virtual void SetTimeOffset(Double_t toffset, Option_t *option="local");
   virtual void UnZoom(); // *MENU*
   virtual void ZoomOut(Double_t factor=0, Double_t offset=0); // *MENU*

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 9; } static void Dictionary(); virtual TClass *IsA() const { return TAxis::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TAxis::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAxis.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 142; } //Axis class
};
# 26 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 2
# 41 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h"
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArrayC.h" 1
// @(#)root/cont:$Id: TArrayC.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   06/03/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TArrayC                                                              //
//                                                                      //
// Array of chars or bytes (8 bits per element).                        //
//                                                                      //
//////////////////////////////////////////////////////////////////////////






class TArrayC : public TArray {

public:
   Char_t *fArray; //[fN] Array of fN chars

   TArrayC();
   TArrayC(Int_t n);
   TArrayC(Int_t n, const Char_t *array);
   TArrayC(const TArrayC &array);
   TArrayC &operator=(const TArrayC &rhs);
   virtual ~TArrayC();

   void Adopt(Int_t n, Char_t *array);
   void AddAt(Char_t c, Int_t i);
   Char_t At(Int_t i) const ;
   void Copy(TArrayC &array) const {array.Set(fN,fArray);}
   const Char_t *GetArray() const { return fArray; }
   Char_t *GetArray() { return fArray; }
   Double_t GetAt(Int_t i) const { return At(i); }
   Stat_t GetSum() const {Stat_t sum=0; for (Int_t i=0;i<fN;i++) sum+=fArray[i]; return sum;}
   void Reset(Char_t val=0) {memset(fArray,val,fN*sizeof(Char_t));}
   void Set(Int_t n);
   void Set(Int_t n, const Char_t *array);
   void SetAt(Double_t v, Int_t i) { AddAt((Char_t)v, i); }
   Char_t &operator[](Int_t i);
   Char_t operator[](Int_t i) const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TArrayC::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TArrayC::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArrayC.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 56; } //Array of chars
};





inline TBuffer &operator>>(TBuffer &buf, TArrayC *&obj)
{
   // Read TArrayC object from buffer.

   obj = (TArrayC *) TArray::ReadArray(buf, TArrayC::Class());
   return buf;
}




inline TBuffer &operator<<(TBuffer &buf, const TArrayC *obj)
{
   // Write a TArrayC object into buffer
   return buf << (TArray*)obj;
}

inline Char_t TArrayC::At(Int_t i) const
{
   if (!BoundsOk("TArrayC::At", i)) return 0;
   return fArray[i];
}

inline Char_t &TArrayC::operator[](Int_t i)
{
   if (!BoundsOk("TArrayC::operator[]", i))
      i = 0;
   return fArray[i];
}

inline Char_t TArrayC::operator[](Int_t i) const
{
   if (!BoundsOk("TArrayC::operator[]", i)) return 0;
   return fArray[i];
}
# 42 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArrayS.h" 1
// @(#)root/cont:$Id: TArrayS.h 30676 2009-10-12 13:54:12Z brun $
// Author: Rene Brun   06/03/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TArrayS                                                              //
//                                                                      //
// Array of shorts (16 bits per element).                               //
//                                                                      //
//////////////////////////////////////////////////////////////////////////






class TArrayS : public TArray {

public:
   Short_t *fArray; //[fN] Array of fN shorts

   TArrayS();
   TArrayS(Int_t n);
   TArrayS(Int_t n, const Short_t *array);
   TArrayS(const TArrayS &array);
   TArrayS &operator=(const TArrayS &rhs);
   virtual ~TArrayS();

   void Adopt(Int_t n, Short_t *array);
   void AddAt(Short_t c, Int_t i);
   Short_t At(Int_t i) const ;
   void Copy(TArrayS &array) const {array.Set(fN,fArray);}
   const Short_t *GetArray() const { return fArray; }
   Short_t *GetArray() { return fArray; }
   Double_t GetAt(Int_t i) const { return At(i); }
   Stat_t GetSum() const {Stat_t sum=0; for (Int_t i=0;i<fN;i++) sum+=fArray[i]; return sum;}
   void Reset() {memset(fArray, 0,fN*sizeof(Short_t));}
   void Reset(Short_t val) {for (Int_t i=0;i<fN;i++) fArray[i] = val;}
   void Set(Int_t n);
   void Set(Int_t n, const Short_t *array);
   void SetAt(Double_t v, Int_t i) { AddAt((Short_t)v, i); }
   Short_t &operator[](Int_t i);
   Short_t operator[](Int_t i) const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TArrayS::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TArrayS::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArrayS.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 57; } //Array of shorts
};




inline TBuffer &operator>>(TBuffer &buf, TArrayS *&obj)
{
   // Read TArrayS object from buffer.

   obj = (TArrayS *) TArray::ReadArray(buf, TArrayS::Class());
   return buf;
}




inline TBuffer &operator<<(TBuffer &buf, const TArrayS *obj)
{
   // Write a TArrayS object into buffer
   return buf << (TArray*)obj;
}

inline Short_t TArrayS::At(Int_t i) const
{
   if (!BoundsOk("TArrayS::At", i)) return 0;
   return fArray[i];
}

inline Short_t &TArrayS::operator[](Int_t i)
{
   if (!BoundsOk("TArrayS::operator[]", i))
      i = 0;
   return fArray[i];
}

inline Short_t TArrayS::operator[](Int_t i) const
{
   if (!BoundsOk("TArrayS::operator[]", i)) return 0;
   return fArray[i];
}
# 45 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArrayI.h" 1
// @(#)root/cont:$Id: TArrayI.h 30676 2009-10-12 13:54:12Z brun $
// Author: Rene Brun   06/03/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TArrayI                                                              //
//                                                                      //
// Array of integers (32 bits per element).                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////






class TArrayI : public TArray {

public:
   Int_t *fArray; //[fN] Array of fN 32 bit integers

   TArrayI();
   TArrayI(Int_t n);
   TArrayI(Int_t n, const Int_t *array);
   TArrayI(const TArrayI &array);
   TArrayI &operator=(const TArrayI &rhs);
   virtual ~TArrayI();

   void Adopt(Int_t n, Int_t *array);
   void AddAt(Int_t c, Int_t i);
   Int_t At(Int_t i) const ;
   void Copy(TArrayI &array) const {array.Set(fN,fArray);}
   const Int_t *GetArray() const { return fArray; }
   Int_t *GetArray() { return fArray; }
   Double_t GetAt(Int_t i) const { return At(i); }
   Stat_t GetSum() const {Stat_t sum=0; for (Int_t i=0;i<fN;i++) sum+=fArray[i]; return sum;}
   void Reset() {memset(fArray, 0, fN*sizeof(Int_t));}
   void Reset(Int_t val) {for (Int_t i=0;i<fN;i++) fArray[i] = val;}
   void Set(Int_t n);
   void Set(Int_t n, const Int_t *array);
   void SetAt(Double_t v, Int_t i) { AddAt((Int_t)v, i); }
   Int_t &operator[](Int_t i);
   Int_t operator[](Int_t i) const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TArrayI::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TArrayI::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArrayI.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 57; } //Array of ints
};





inline TBuffer &operator>>(TBuffer &buf, TArrayI *&obj)
{
   // Read TArrayI object from buffer.

   obj = (TArrayI *) TArray::ReadArray(buf, TArrayI::Class());
   return buf;
}




inline TBuffer &operator<<(TBuffer &buf, const TArrayI *obj)
{
   // Write a TArrayI object into buffer
   return buf << (TArray*)obj;
}

inline Int_t TArrayI::At(Int_t i) const
{
   if (!BoundsOk("TArrayI::At", i)) return 0;
   return fArray[i];
}

inline Int_t &TArrayI::operator[](Int_t i)
{
   if (!BoundsOk("TArrayI::operator[]", i))
      i = 0;
   return fArray[i];
}

inline Int_t TArrayI::operator[](Int_t i) const
{
   if (!BoundsOk("TArrayI::operator[]", i)) return 0;
   return fArray[i];
}
# 48 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArrayF.h" 1
// @(#)root/cont:$Id: TArrayF.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   06/03/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TArrayF                                                              //
//                                                                      //
// Array of floats (32 bits per element).                               //
//                                                                      //
//////////////////////////////////////////////////////////////////////////






class TArrayF : public TArray {

public:
   Float_t *fArray; //[fN] Array of fN floats

   TArrayF();
   TArrayF(Int_t n);
   TArrayF(Int_t n, const Float_t *array);
   TArrayF(const TArrayF &array);
   TArrayF &operator=(const TArrayF &rhs);
   virtual ~TArrayF();

   void Adopt(Int_t n, Float_t *array);
   void AddAt(Float_t c, Int_t i);
   Float_t At(Int_t i) const ;
   void Copy(TArrayF &array) const {array.Set(fN,fArray);}
   const Float_t *GetArray() const { return fArray; }
   Float_t *GetArray() { return fArray; }
   Double_t GetAt(Int_t i) const { return At(i); }
   Stat_t GetSum() const {Stat_t sum=0; for (Int_t i=0;i<fN;i++) sum+=fArray[i]; return sum;}
   void Reset() {memset(fArray, 0, fN*sizeof(Float_t));}
   void Reset(Float_t val) {for (Int_t i=0;i<fN;i++) fArray[i] = val;}
   void Set(Int_t n);
   void Set(Int_t n, const Float_t *array);
   void SetAt(Double_t v, Int_t i) { AddAt((Float_t)v, i); }
   Float_t &operator[](Int_t i);
   Float_t operator[](Int_t i) const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TArrayF::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TArrayF::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TArrayF.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 57; } //Array of floats
};




inline TBuffer &operator>>(TBuffer &buf, TArrayF *&obj)
{
   // Read TArrayF object from buffer.

   obj = (TArrayF *) TArray::ReadArray(buf, TArrayF::Class());
   return buf;
}




inline TBuffer &operator<<(TBuffer &buf, const TArrayF *obj)
{
   // Write a TArrayF object into buffer
   return buf << (TArray*)obj;
}

inline Float_t TArrayF::At(Int_t i) const
{
   if (!BoundsOk("TArrayF::At", i)) return 0;
   return fArray[i];
}

inline Float_t &TArrayF::operator[](Int_t i)
{
   if (!BoundsOk("TArrayF::operator[]", i))
      i = 0;
   return fArray[i];
}

inline Float_t TArrayF::operator[](Int_t i) const
{
   if (!BoundsOk("TArrayF::operator[]", i)) return 0;
   return fArray[i];
}
# 51 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 2




# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Foption.h" 1
/* @(#)root/hist:$Id: Foption.h 31207 2009-11-16 16:52:00Z moneta $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Foption                                                              //
//                                                                      //
// Histogram fit options structure.                                     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


struct Foption_t {
//*-*      chopt may be the concatenation of the following options:
//*-*      =======================================================
//*-*
//*-*   The following structure members are set to 1 if the option is selected:
   int Quiet; // "Q"  Quiet mode. No print
   int Verbose; // "V"  Verbose mode. Print results after each iteration
   int Bound; // "B"  When using pre-defined functions user parameter settings are used instead of default one
   int Chi2; // "X"  For fitting THnsparse use chi2 method (default is likelihood)
   int Like; // "L"  Use Log Likelihood. Default is chisquare method except fitting THnsparse
   int User; // "U"  Use a User specified fitting algorithm (via SetFCN)
   int W1; // "W"  Set all the weights to 1. Ignore error bars
   int Errors; // "E"  Performs a better error evaluation, calling HESSE and MINOS
   int More; // "M"  Improve fit results.
   int Range; // "R"  Use the range stored in function
   int Gradient; // "G"  Option to compute derivatives analytically
   int Nostore; // "N"  If set, do not store the function graph
   int Nograph; // "0"  If set, do not display the function graph
   int Plus; // "+"  Add new function (default is replace)
   int Integral; // "I"  Use function integral instead of function in center of bin
   int Nochisq; // "C"  In case of linear fitting, don't calculate the chisquare
   int Minuit; // "F"  If fitting a polN, switch to minuit fitter
   int NoErrX; // "EX0" or "T" When fitting a TGraphErrors do not consider error in coordinates 
   int Robust; // "ROB" or "H":  For a TGraph use robust fitting
   int StoreResult; // "S": Stores the result in a TFitResult structure
   double hRobust; //  value of h parameter used in robust fitting 

  Foption_t() :
      Quiet (0),
      Verbose (0),
      Bound (0),
      Chi2 (0),
      Like (0),
      User (0),
      W1 (0),
      Errors (0),
      More (0),
      Range (0),
      Gradient (0),
      Nostore (0),
      Nograph (0),
      Plus (0),
      Integral (0),
      Nochisq (0),
      Minuit (0),
      NoErrX (0),
      Robust (0),
      StoreResult (0),
      hRobust (0)
   {}
};
# 56 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVectorFfwd.h" 1
/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TVectorF                                                             //
//                                                                      //
//  Forward declaration of TVectorT<Float_t>                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





template<class Element> class TVectorT;
typedef TVectorT<Float_t> TVectorF;
# 59 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVectorDfwd.h" 1
/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TVectorD                                                             //
//                                                                      //
//  Forward declaration of TVectorT<Double_t>                           //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





template<class Element> class TVectorT;
typedef TVectorT<Double_t> TVectorD;
# 62 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 2


# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/float.h" 1
# 65 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 2

class TF1;
class TH1D;
class TBrowser;
class TDirectory;
class TList;
class TCollection;
class TVirtualFFT;
class TVirtualHistPainter;

# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFitResultPtr.h" 1
// @(#)root/mathcore:$Id: TFitResultPtr.h 31262 2009-11-18 07:38:37Z brun $
// Author: David Gonzalez Maline Tue Nov 10 15:01:24 2009

/*************************************************************************
 * Copyright (C) 1995-2009, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TFitResultPtr                                                        //
//                                                                      //
// Provides an indirection to TFitResult class and with a semantics     //
// identical to a TFitResult pointer                                    //
//                                                                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TFitResult;

class TFitResultPtr {
public:

   TFitResultPtr(int status = -1): fStatus(status), fPointer(0) {};

   TFitResultPtr(TFitResult* p);

   TFitResultPtr(const TFitResultPtr& rhs);

   operator int() const { return fStatus; }

   TFitResult& operator*() const;

   TFitResult* operator->() const;

   TFitResult* Get() const { return fPointer; }

   TFitResultPtr& operator= (const TFitResultPtr& rhs);

   virtual ~TFitResultPtr();

private:

   int fStatus; // fit status code
   TFitResult* fPointer; // Smart Pointer to TFitResult class  

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TFitResultPtr::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TFitResultPtr::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFitResultPtr.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 57; } //indirection to TFitResult
};
# 76 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 2

class TH1 : public TNamed, public TAttLine, public TAttFill, public TAttMarker {

public:

   // enumeration specifying type of statistics for bin errors
   enum EBinErrorOpt {
         kNormal = 0, // errors with Normal (Wald) approximation: errorUp=errorLow= sqrt(N)
         kPoisson = 1 , // errors from Poisson interval at 68.3% (1 sigma)
         kPoisson2 = 2 // errors from Poisson interval at 95% CL (~ 2 sigma)            
   };

protected:
    Int_t fNcells; //number of bins(1D), cells (2D) +U/Overflows
    TAxis fXaxis; //X axis descriptor
    TAxis fYaxis; //Y axis descriptor
    TAxis fZaxis; //Z axis descriptor
    Short_t fBarOffset; //(1000*offset) for bar charts or legos
    Short_t fBarWidth; //(1000*width) for bar charts or legos
    Double_t fEntries; //Number of entries
    Double_t fTsumw; //Total Sum of weights
    Double_t fTsumw2; //Total Sum of squares of weights
    Double_t fTsumwx; //Total Sum of weight*X
    Double_t fTsumwx2; //Total Sum of weight*X*X
    Double_t fMaximum; //Maximum value for plotting
    Double_t fMinimum; //Minimum value for plotting
    Double_t fNormFactor; //Normalization factor
    TArrayD fContour; //Array to display contour levels
    TArrayD fSumw2; //Array of sum of squares of weights
    TString fOption; //histogram options
    TList *fFunctions; //->Pointer to list of functions (fits and user)
    Int_t fBufferSize; //fBuffer size
    Double_t *fBuffer; //[fBufferSize] entry buffer
    TDirectory *fDirectory; //!Pointer to directory holding this histogram
    Int_t fDimension; //!Histogram dimension (1, 2 or 3 dim)
    Double_t *fIntegral; //!Integral of bins used by GetRandom
    TVirtualHistPainter *fPainter; //!pointer to histogram painter
    EBinErrorOpt fBinStatErrOpt; //option for bin statistical errors 
    static Int_t fgBufferSize; //!default buffer size for automatic histograms
    static Bool_t fgAddDirectory; //!flag to add histograms to the directory
    static Bool_t fgStatOverflows; //!flag to use under/overflows in statistics
    static Bool_t fgDefaultSumw2; //!flag to call TH1::Sumw2 automatically at histogram creation time

public:
   static Int_t FitOptionsMake(Option_t *option, Foption_t &Foption);

private:
   Int_t AxisChoice(Option_t *axis) const;
   void Build();

   TH1& operator=(const TH1&); // Not implemented


protected:
   TH1();
   TH1(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup);
   TH1(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins);
   TH1(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins);
   virtual void Copy(TObject &hnew) const;
   virtual Int_t BufferFill(Double_t x, Double_t w);
   virtual Bool_t FindNewAxisLimits(const TAxis* axis, const Double_t point, Double_t& newMin, Double_t &newMax);
   virtual void SavePrimitiveHelp(ostream &out, const char *hname, Option_t *option = "");
   static Bool_t RecomputeAxisLimits(TAxis& destAxis, const TAxis& anAxis);
   static Bool_t SameLimitsAndNBins(const TAxis& axis1, const TAxis& axis2);

   virtual Double_t DoIntegral(Int_t ix1, Int_t ix2, Int_t iy1, Int_t iy2, Int_t iz1, Int_t iz2, Double_t & err,
                               Option_t * opt, Bool_t doerr = kFALSE) const;


   static bool CheckAxisLimits(const TAxis* a1, const TAxis* a2);
   static bool CheckBinLimits(const TAxis* a1, const TAxis* a2);
   static bool CheckBinLabels(const TAxis* a1, const TAxis* a2);
   static bool CheckEqualAxes(const TAxis* a1, const TAxis* a2);
   static bool CheckConsistentSubAxes(const TAxis *a1, Int_t firstBin1, Int_t lastBin1, const TAxis *a2, Int_t firstBin2=0, Int_t lastBin2=0);
   static bool CheckConsistency(const TH1* h1, const TH1* h2);

public:
   // TH1 status bits
   enum {
      kNoStats = (1ULL << (9)), // don't draw stats box
      kUserContour = (1ULL << (10)), // user specified contour levels
      kCanRebin = (1ULL << (11)), // can rebin axis
      kLogX = (1ULL << (15)), // X-axis in log scale
      kIsZoomed = (1ULL << (16)), // bit set when zooming on Y axis
      kNoTitle = (1ULL << (17)), // don't draw the histogram title
      kIsAverage = (1ULL << (18)) // Bin contents are average (used by Add)
   };
   // size of statistics data (size of  array used in GetStats()/ PutStats ) 
   // s[0]  = sumw       s[1]  = sumw2
   // s[2]  = sumwx      s[3]  = sumwx2                     
   // s[4]  = sumwy      s[5]  = sumwy2   s[6]  = sumwxy
   // s[7]  = sumwz      s[8]  = sumwz2   s[9]  = sumwxz   s[10]  = sumwyz  
   // s[11] = sumwt      s[12] = sumwt2                 (11 and 12 used only by TProfile3D)
   enum {
      kNstat = 13 // size of statistics data (up to TProfile3D)
   };



   TH1(const TH1&);
   virtual ~TH1();

   virtual Bool_t Add(TF1 *h1, Double_t c1=1, Option_t *option="");
   virtual Bool_t Add(const TH1 *h1, Double_t c1=1);
   virtual Bool_t Add(const TH1 *h, const TH1 *h2, Double_t c1=1, Double_t c2=1); // *MENU*
   virtual void AddBinContent(Int_t bin);
   virtual void AddBinContent(Int_t bin, Double_t w);
   static void AddDirectory(Bool_t add=kTRUE);
   static Bool_t AddDirectoryStatus();
   virtual void Browse(TBrowser *b);
   virtual Double_t Chi2Test(const TH1* h2, Option_t *option = "UU", Double_t *res = 0) const;
   virtual Double_t Chi2TestX(const TH1* h2, Double_t &chi2, Int_t &ndf, Int_t &igood,Option_t *option = "UU", Double_t *res = 0) const;

   virtual Double_t ComputeIntegral();
   virtual void DirectoryAutoAdd(TDirectory *);
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual Bool_t Divide(TF1 *f1, Double_t c1=1);
   virtual Bool_t Divide(const TH1 *h1);
   virtual Bool_t Divide(const TH1 *h1, const TH1 *h2, Double_t c1=1, Double_t c2=1, Option_t *option=""); // *MENU*
   virtual void Draw(Option_t *option="");
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual TH1 *DrawNormalized(Option_t *option="", Double_t norm=1) const;
   virtual void DrawPanel(); // *MENU*
   virtual Int_t BufferEmpty(Int_t action=0);
   virtual void Eval(TF1 *f1, Option_t *option="");
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   virtual TH1 *FFT(TH1* h_output, Option_t *option);
   virtual Int_t Fill(Double_t x);
   virtual Int_t Fill(Double_t x, Double_t w);
   virtual Int_t Fill(const char *name, Double_t w);
   virtual void FillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride=1);
   virtual void FillN(Int_t, const Double_t *, const Double_t *, const Double_t *, Int_t) {;}
   virtual void FillRandom(const char *fname, Int_t ntimes=5000);
   virtual void FillRandom(TH1 *h, Int_t ntimes=5000);
   virtual Int_t FindBin(Double_t x, Double_t y=0, Double_t z=0);
   virtual Int_t FindFixBin(Double_t x, Double_t y=0, Double_t z=0) const;
   virtual Int_t FindFirstBinAbove(Double_t threshold=0, Int_t axis=1) const;
   virtual Int_t FindLastBinAbove (Double_t threshold=0, Int_t axis=1) const;
   virtual TObject *FindObject(const char *name) const;
   virtual TObject *FindObject(const TObject *obj) const;
   virtual TFitResultPtr Fit(const char *formula ,Option_t *option="" ,Option_t *goption="", Double_t xmin=0, Double_t xmax=0); // *MENU*
   virtual TFitResultPtr Fit(TF1 *f1 ,Option_t *option="" ,Option_t *goption="", Double_t xmin=0, Double_t xmax=0);
   virtual void FitPanel(); // *MENU*
   TH1 *GetAsymmetry(TH1* h2, Double_t c2=1, Double_t dc2=0);
   Int_t GetBufferLength() const {return fBuffer ? (Int_t)fBuffer[0] : 0;}
   Int_t GetBufferSize () const {return fBufferSize;}
   const Double_t *GetBuffer() const {return fBuffer;}
   static Int_t GetDefaultBufferSize();
   virtual Double_t *GetIntegral();

   TList *GetListOfFunctions() const { return fFunctions; }

   virtual Int_t GetNdivisions(Option_t *axis="X") const;
   virtual Color_t GetAxisColor(Option_t *axis="X") const;
   virtual Color_t GetLabelColor(Option_t *axis="X") const;
   virtual Style_t GetLabelFont(Option_t *axis="X") const;
   virtual Float_t GetLabelOffset(Option_t *axis="X") const;
   virtual Float_t GetLabelSize(Option_t *axis="X") const;
   virtual Style_t GetTitleFont(Option_t *axis="X") const;
   virtual Float_t GetTitleOffset(Option_t *axis="X") const;
   virtual Float_t GetTitleSize(Option_t *axis="X") const;
   virtual Float_t GetTickLength(Option_t *axis="X") const;
   virtual Float_t GetBarOffset() const {return Float_t(0.001*Float_t(fBarOffset));}
   virtual Float_t GetBarWidth() const {return Float_t(0.001*Float_t(fBarWidth));}
   virtual Int_t GetContour(Double_t *levels=0);
   virtual Double_t GetContourLevel(Int_t level) const;
   virtual Double_t GetContourLevelPad(Int_t level) const;

   virtual Int_t GetBin(Int_t binx, Int_t biny=0, Int_t binz=0) const;
   virtual void GetBinXYZ(Int_t binglobal, Int_t &binx, Int_t &biny, Int_t &binz) const;
   virtual Double_t GetBinCenter(Int_t bin) const {return fXaxis.GetBinCenter(bin);}
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t binx, Int_t biny) const;
   virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t binz) const;
   virtual Double_t GetBinError(Int_t bin) const;
   virtual Double_t GetBinError(Int_t binx, Int_t biny) const;
   virtual Double_t GetBinError(Int_t binx, Int_t biny, Int_t binz) const;
   virtual Double_t GetBinErrorLow(Int_t bin) const;
   virtual Double_t GetBinErrorUp(Int_t bin) const;
   virtual EBinErrorOpt GetBinErrorOption() const { return fBinStatErrOpt; }
   virtual Double_t GetBinLowEdge(Int_t bin) const {return fXaxis.GetBinLowEdge(bin);}
   virtual Double_t GetBinWidth(Int_t bin) const {return fXaxis.GetBinWidth(bin);}
   virtual Double_t GetBinWithContent(Double_t c, Int_t &binx, Int_t firstx=0, Int_t lastx=0,Double_t maxdiff=0) const;
   virtual Double_t GetCellContent(Int_t binx, Int_t biny) const;
   virtual Double_t GetCellError(Int_t binx, Int_t biny) const;
   virtual void GetCenter(Double_t *center) const {fXaxis.GetCenter(center);}
   static Bool_t GetDefaultSumw2();
   TDirectory *GetDirectory() const {return fDirectory;}
   virtual Double_t GetEntries() const;
   virtual Double_t GetEffectiveEntries() const;
   virtual TF1 *GetFunction(const char *name) const;
   virtual Int_t GetDimension() const { return fDimension; }
   virtual Double_t GetKurtosis(Int_t axis=1) const;
   virtual void GetLowEdge(Double_t *edge) const {fXaxis.GetLowEdge(edge);}
   virtual Double_t GetMaximum(Double_t maxval=(3.40282e+38)) const;
   virtual Int_t GetMaximumBin() const;
   virtual Int_t GetMaximumBin(Int_t &locmax, Int_t &locmay, Int_t &locmaz) const;
   virtual Double_t GetMaximumStored() const {return fMaximum;}
   virtual Double_t GetMinimum(Double_t minval=-(3.40282e+38)) const;
   virtual Int_t GetMinimumBin() const;
   virtual Int_t GetMinimumBin(Int_t &locmix, Int_t &locmiy, Int_t &locmiz) const;
   virtual Double_t GetMinimumStored() const {return fMinimum;}
   virtual Double_t GetMean(Int_t axis=1) const;
   virtual Double_t GetMeanError(Int_t axis=1) const;
   virtual Int_t GetNbinsX() const {return fXaxis.GetNbins();}
   virtual Int_t GetNbinsY() const {return fYaxis.GetNbins();}
   virtual Int_t GetNbinsZ() const {return fZaxis.GetNbins();}
   virtual Double_t GetNormFactor() const {return fNormFactor;}
   virtual char *GetObjectInfo(Int_t px, Int_t py) const;
   Option_t *GetOption() const {return fOption.Data();}

   TVirtualHistPainter *GetPainter(Option_t *option="");

   virtual Int_t GetQuantiles(Int_t nprobSum, Double_t *q, const Double_t *probSum=0);
   virtual Double_t GetRandom() const;
   virtual void GetStats(Double_t *stats) const;
   virtual Double_t GetSumOfWeights() const;
   virtual TArrayD *GetSumw2() {return &fSumw2;}
   virtual const TArrayD *GetSumw2() const {return &fSumw2;}
   virtual Int_t GetSumw2N() const {return fSumw2.fN;}
   virtual Double_t GetRMS(Int_t axis=1) const;
   virtual Double_t GetRMSError(Int_t axis=1) const;
   virtual Double_t GetSkewness(Int_t axis=1) const;
           TAxis *GetXaxis() const;
           TAxis *GetYaxis() const;
           TAxis *GetZaxis() const;
   virtual Double_t Integral(Option_t *option="") const;
   virtual Double_t Integral(Int_t binx1, Int_t binx2, Option_t *option="") const;
   virtual Double_t IntegralAndError(Int_t binx1, Int_t binx2, Double_t & err, Option_t *option="") const;
   virtual Double_t Interpolate(Double_t x);
   virtual Double_t Interpolate(Double_t x, Double_t y);
   virtual Double_t Interpolate(Double_t x, Double_t y, Double_t z);
           Bool_t IsBinOverflow(Int_t bin) const;
           Bool_t IsBinUnderflow(Int_t bin) const;
   virtual Double_t KolmogorovTest(const TH1 *h2, Option_t *option="") const;
   virtual void LabelsDeflate(Option_t *axis="X");
   virtual void LabelsInflate(Option_t *axis="X");
   virtual void LabelsOption(Option_t *option="h", Option_t *axis="X");
   virtual Long64_t Merge(TCollection *list);
   virtual Bool_t Multiply(TF1 *h1, Double_t c1=1);
   virtual Bool_t Multiply(const TH1 *h1);
   virtual Bool_t Multiply(const TH1 *h1, const TH1 *h2, Double_t c1=1, Double_t c2=1, Option_t *option=""); // *MENU*
   virtual void Paint(Option_t *option="");
   virtual void Print(Option_t *option="") const;
   virtual void PutStats(Double_t *stats);
   virtual TH1 *Rebin(Int_t ngroup=2, const char*newname="", const Double_t *xbins=0); // *MENU*
   virtual TH1 *RebinX(Int_t ngroup=2, const char*newname="") { return Rebin(ngroup,newname, (Double_t*) 0); }
   virtual void RebinAxis(Double_t x, TAxis *axis);
   virtual void Rebuild(Option_t *option="");
   virtual void RecursiveRemove(TObject *obj);
   virtual void Reset(Option_t *option="");
   virtual void ResetStats();
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void Scale(Double_t c1=1, Option_t *option="");
   virtual void SetAxisColor(Color_t color=1, Option_t *axis="X");
   virtual void SetAxisRange(Double_t xmin, Double_t xmax, Option_t *axis="X");
   virtual void SetBarOffset(Float_t offset=0.25) {fBarOffset = Short_t(1000*offset);}
   virtual void SetBarWidth(Float_t width=0.5) {fBarWidth = Short_t(1000*width);}
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t binx, Int_t biny, Double_t content);
   virtual void SetBinContent(Int_t binx, Int_t biny, Int_t binz, Double_t content);
   virtual void SetBinError(Int_t bin, Double_t error);
   virtual void SetBinError(Int_t binx, Int_t biny, Double_t error);
   virtual void SetBinError(Int_t binx, Int_t biny, Int_t binz, Double_t error);
   virtual void SetBins(Int_t nx, Double_t xmin, Double_t xmax);
   virtual void SetBins(Int_t nx, const Double_t *xBins);
   virtual void SetBins(Int_t nx, Double_t xmin, Double_t xmax, Int_t ny, Double_t ymin, Double_t ymax);
   virtual void SetBins(Int_t nx, const Double_t *xBins, Int_t ny, const Double_t *yBins);
   virtual void SetBins(Int_t nx, Double_t xmin, Double_t xmax, Int_t ny, Double_t ymin, Double_t ymax,
                            Int_t nz, Double_t zmin, Double_t zmax);
   virtual void SetBins(Int_t nx, const Double_t *xBins, Int_t ny, const Double_t * yBins, Int_t nz,
       const Double_t *zBins);
   virtual void SetBinsLength(Int_t = -1) { } //redefined in derived classes
   virtual void SetBinErrorOption(EBinErrorOpt type) { fBinStatErrOpt = type; }
   virtual void SetBuffer(Int_t buffersize, Option_t *option="");
   virtual void SetCellContent(Int_t binx, Int_t biny, Double_t content);
   virtual void SetCellError(Int_t binx, Int_t biny, Double_t content);
   virtual void SetContent(const Double_t *content);
   virtual void SetContour(Int_t nlevels, const Double_t *levels=0);
   virtual void SetContourLevel(Int_t level, Double_t value);
   static void SetDefaultBufferSize(Int_t buffersize=1000);
   static void SetDefaultSumw2(Bool_t sumw2=kTRUE);
   virtual void SetDirectory(TDirectory *dir);
   virtual void SetEntries(Double_t n) {fEntries = n;};
   virtual void SetError(const Double_t *error);
   virtual void SetLabelColor(Color_t color=1, Option_t *axis="X");
   virtual void SetLabelFont(Style_t font=62, Option_t *axis="X");
   virtual void SetLabelOffset(Float_t offset=0.005, Option_t *axis="X");
   virtual void SetLabelSize(Float_t size=0.02, Option_t *axis="X");

   virtual void SetMaximum(Double_t maximum=-1111); // *MENU*
   virtual void SetMinimum(Double_t minimum=-1111); // *MENU*
   virtual void SetName(const char *name); // *MENU*
   virtual void SetNameTitle(const char *name, const char *title);
   virtual void SetNdivisions(Int_t n=510, Option_t *axis="X");
   virtual void SetNormFactor(Double_t factor=1) {fNormFactor = factor;}
   virtual void SetStats(Bool_t stats=kTRUE); // *MENU*
   virtual void SetOption(Option_t *option=" ") {fOption = option;}
   virtual void SetTickLength(Float_t length=0.02, Option_t *axis="X");
   virtual void SetTitleFont(Style_t font=62, Option_t *axis="X");
   virtual void SetTitleOffset(Float_t offset=1, Option_t *axis="X");
   virtual void SetTitleSize(Float_t size=0.02, Option_t *axis="X");
   virtual void SetTitle(const char *title); // *MENU*
   virtual void SetXTitle(const char *title) {fXaxis.SetTitle(title);}
   virtual void SetYTitle(const char *title) {fYaxis.SetTitle(title);}
   virtual void SetZTitle(const char *title) {fZaxis.SetTitle(title);}
   virtual TH1 *ShowBackground(Int_t niter=20, Option_t *option="same"); // *MENU*
   virtual Int_t ShowPeaks(Double_t sigma=2, Option_t *option="", Double_t threshold=0.05); // *MENU*
   virtual void Smooth(Int_t ntimes=1, Option_t *option=""); // *MENU*
   static void SmoothArray(Int_t NN, Double_t *XX, Int_t ntimes=1);
   static void StatOverflows(Bool_t flag=kTRUE);
   virtual void Sumw2();
   void UseCurrentStyle();
   static TH1 *TransformHisto(TVirtualFFT *fft, TH1* h_output, Option_t *option);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 7; } static void Dictionary(); virtual TClass *IsA() const { return TH1::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH1::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 391; } //1-Dim histogram base class
};

//________________________________________________________________________

class TH1C : public TH1, public TArrayC {

public:
   TH1C();
   TH1C(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup);
   TH1C(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins);
   TH1C(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins);
   TH1C(const TH1C &h1c);
   virtual ~TH1C();

   virtual void AddBinContent(Int_t bin);
   virtual void AddBinContent(Int_t bin, Double_t w);
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t bin, Int_t) const {return GetBinContent(bin);}
   virtual Double_t GetBinContent(Int_t bin, Int_t, Int_t) const {return GetBinContent(bin);}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t bin, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinContent(Int_t bin, Int_t, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH1C& operator=(const TH1C &h1);
   friend TH1C operator*(Double_t c1, const TH1C &h1);
   friend TH1C operator*(const TH1C &h1, Double_t c1);
   friend TH1C operator+(const TH1C &h1, const TH1C &h2);
   friend TH1C operator-(const TH1C &h1, const TH1C &h2);
   friend TH1C operator*(const TH1C &h1, const TH1C &h2);
   friend TH1C operator/(const TH1C &h1, const TH1C &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TH1C::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH1C::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 426; } //1-Dim histograms (one char per channel)
};

TH1C operator*(Double_t c1, const TH1C &h1);
inline
TH1C operator*(const TH1C &h1, Double_t c1) {return operator*(c1,h1);}
TH1C operator+(const TH1C &h1, const TH1C &h2);
TH1C operator-(const TH1C &h1, const TH1C &h2);
TH1C operator*(const TH1C &h1, const TH1C &h2);
TH1C operator/(const TH1C &h1, const TH1C &h2);

//________________________________________________________________________

class TH1S : public TH1, public TArrayS {

public:
   TH1S();
   TH1S(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup);
   TH1S(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins);
   TH1S(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins);
   TH1S(const TH1S &h1s);
   virtual ~TH1S();

   virtual void AddBinContent(Int_t bin);
   virtual void AddBinContent(Int_t bin, Double_t w);
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t bin, Int_t) const {return GetBinContent(bin);}
   virtual Double_t GetBinContent(Int_t bin, Int_t, Int_t) const {return GetBinContent(bin);}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t bin, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinContent(Int_t bin, Int_t, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH1S& operator=(const TH1S &h1);
   friend TH1S operator*(Double_t c1, const TH1S &h1);
   friend TH1S operator*(const TH1S &h1, Double_t c1);
   friend TH1S operator+(const TH1S &h1, const TH1S &h2);
   friend TH1S operator-(const TH1S &h1, const TH1S &h2);
   friend TH1S operator*(const TH1S &h1, const TH1S &h2);
   friend TH1S operator/(const TH1S &h1, const TH1S &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TH1S::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH1S::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 469; } //1-Dim histograms (one short per channel)
};

TH1S operator*(Double_t c1, const TH1S &h1);
inline
TH1S operator*(const TH1S &h1, Double_t c1) {return operator*(c1,h1);}
TH1S operator+(const TH1S &h1, const TH1S &h2);
TH1S operator-(const TH1S &h1, const TH1S &h2);
TH1S operator*(const TH1S &h1, const TH1S &h2);
TH1S operator/(const TH1S &h1, const TH1S &h2);

//________________________________________________________________________

class TH1I: public TH1, public TArrayI {

public:
   TH1I();
   TH1I(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup);
   TH1I(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins);
   TH1I(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins);
   TH1I(const TH1I &h1i);
   virtual ~TH1I();

   virtual void AddBinContent(Int_t bin);
   virtual void AddBinContent(Int_t bin, Double_t w);
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t bin, Int_t) const {return GetBinContent(bin);}
   virtual Double_t GetBinContent(Int_t bin, Int_t, Int_t) const {return GetBinContent(bin);}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t bin, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinContent(Int_t bin, Int_t, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH1I& operator=(const TH1I &h1);
   friend TH1I operator*(Double_t c1, const TH1I &h1);
   friend TH1I operator*(const TH1I &h1, Double_t c1);
   friend TH1I operator+(const TH1I &h1, const TH1I &h2);
   friend TH1I operator-(const TH1I &h1, const TH1I &h2);
   friend TH1I operator*(const TH1I &h1, const TH1I &h2);
   friend TH1I operator/(const TH1I &h1, const TH1I &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TH1I::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH1I::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 512; } //1-Dim histograms (one 32 bits integer per channel)
};

TH1I operator*(Double_t c1, const TH1I &h1);
inline
TH1I operator*(const TH1I &h1, Double_t c1) {return operator*(c1,h1);}
TH1I operator+(const TH1I &h1, const TH1I &h2);
TH1I operator-(const TH1I &h1, const TH1I &h2);
TH1I operator*(const TH1I &h1, const TH1I &h2);
TH1I operator/(const TH1I &h1, const TH1I &h2);

//________________________________________________________________________

class TH1F : public TH1, public TArrayF {

public:
   TH1F();
   TH1F(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup);
   TH1F(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins);
   TH1F(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins);
   TH1F(const TVectorF &v);
   TH1F(const TH1F &h1f);
   virtual ~TH1F();

   virtual void AddBinContent(Int_t bin) {++fArray[bin];}
   virtual void AddBinContent(Int_t bin, Double_t w)
                                 {fArray[bin] += Float_t (w);}
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t bin, Int_t) const {return GetBinContent(bin);}
   virtual Double_t GetBinContent(Int_t bin, Int_t, Int_t) const {return GetBinContent(bin);}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t bin, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinContent(Int_t bin, Int_t, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH1F& operator=(const TH1F &h1);
   friend TH1F operator*(Double_t c1, const TH1F &h1);
   friend TH1F operator*(const TH1F &h1, Double_t c1);
   friend TH1F operator+(const TH1F &h1, const TH1F &h2);
   friend TH1F operator-(const TH1F &h1, const TH1F &h2);
   friend TH1F operator*(const TH1F &h1, const TH1F &h2);
   friend TH1F operator/(const TH1F &h1, const TH1F &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TH1F::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH1F::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 557; } //1-Dim histograms (one float per channel)
};

TH1F operator*(Double_t c1, const TH1F &h1);
inline
TH1F operator*(const TH1F &h1, Double_t c1) {return operator*(c1,h1);}
TH1F operator+(const TH1F &h1, const TH1F &h2);
TH1F operator-(const TH1F &h1, const TH1F &h2);
TH1F operator*(const TH1F &h1, const TH1F &h2);
TH1F operator/(const TH1F &h1, const TH1F &h2);

//________________________________________________________________________

class TH1D : public TH1, public TArrayD {

public:
   TH1D();
   TH1D(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup);
   TH1D(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins);
   TH1D(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins);
   TH1D(const TVectorD &v);
   TH1D(const TH1D &h1d);
   virtual ~TH1D();

   virtual void AddBinContent(Int_t bin) {++fArray[bin];}
   virtual void AddBinContent(Int_t bin, Double_t w)
                                 {fArray[bin] += Double_t (w);}
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t bin, Int_t) const {return GetBinContent(bin);}
   virtual Double_t GetBinContent(Int_t bin, Int_t, Int_t) const {return GetBinContent(bin);}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t bin, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinContent(Int_t bin, Int_t, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH1D& operator=(const TH1D &h1);
   friend TH1D operator*(Double_t c1, const TH1D &h1);
   friend TH1D operator*(const TH1D &h1, Double_t c1);
   friend TH1D operator+(const TH1D &h1, const TH1D &h2);
   friend TH1D operator-(const TH1D &h1, const TH1D &h2);
   friend TH1D operator*(const TH1D &h1, const TH1D &h2);
   friend TH1D operator/(const TH1D &h1, const TH1D &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TH1D::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH1D::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 602; } //1-Dim histograms (one double per channel)
};

TH1D operator*(Double_t c1, const TH1D &h1);
inline
TH1D operator*(const TH1D &h1, Double_t c1) {return operator*(c1,h1);}
TH1D operator+(const TH1D &h1, const TH1D &h2);
TH1D operator-(const TH1D &h1, const TH1D &h2);
TH1D operator*(const TH1D &h1, const TH1D &h2);
TH1D operator/(const TH1D &h1, const TH1D &h2);

   extern TH1 *R__H(Int_t hid);
   extern TH1 *R__H(const char *hname);
# 5 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h" 1
// @(#)root/hist:$Id: TH2.h 44515 2012-06-04 14:16:56Z moneta $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TH2                                                                  //
//                                                                      //
// 2-Dim histogram base class.                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMatrixFBasefwd.h" 1
// @(#)root/matrix:$Id: TMatrixFBasefwd.h 30815 2009-10-20 13:49:22Z rdm $
// Authors: Fons Rademakers, Eddy Offermann   Nov 2003

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixFBase                                                         //
//                                                                      //
//  Forward declaration of TMatrixTBase<Float_t>                        //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





template<class Element> class TMatrixTBase;
typedef TMatrixTBase<Float_t> TMatrixFBase;
# 29 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMatrixDBasefwd.h" 1
// @(#)root/matrix:$Id: TMatrixDBasefwd.h 30815 2009-10-20 13:49:22Z rdm $
// Authors: Fons Rademakers, Eddy Offermann   Nov 2003

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixDBase                                                         //
//                                                                      //
//  Forward declaration of TMatrixTBase<Double_t>                       //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





template<class Element> class TMatrixTBase;
typedef TMatrixTBase<Double_t> TMatrixDBase;
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h" 2


class TProfile;

class TH2 : public TH1 {

protected:
   Double_t fScalefactor; //Scale factor
   Double_t fTsumwy; //Total Sum of weight*Y
   Double_t fTsumwy2; //Total Sum of weight*Y*Y
   Double_t fTsumwxy; //Total Sum of weight*X*Y

   TH2();
   TH2(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                         ,Int_t nbinsy,Double_t ylow,Double_t yup);
   TH2(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                         ,Int_t nbinsy,Double_t ylow,Double_t yup);
   TH2(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                         ,Int_t nbinsy,const Double_t *ybins);
   TH2(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                         ,Int_t nbinsy,const Double_t *ybins);
   TH2(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                         ,Int_t nbinsy,const Float_t *ybins);

   virtual Int_t BufferFill(Double_t x, Double_t y, Double_t w);
   virtual TH1D *DoProjection(bool onX, const char *name, Int_t firstbin, Int_t lastbin, Option_t *option) const;
   virtual TProfile *DoProfile(bool onX, const char *name, Int_t firstbin, Int_t lastbin, Option_t *option) const;
   virtual void DoFitSlices(bool onX, TF1 *f1, Int_t firstbin, Int_t lastbin, Int_t cut, Option_t *option, TObjArray* arr);

   Int_t BufferFill(Double_t, Double_t) {return -2;} //may not use
   Int_t Fill(Double_t); //MayNotUse
   Int_t Fill(const char*, Double_t) { return Fill(0);} //MayNotUse

public:
   TH2(const TH2&);
   virtual ~TH2();
   virtual Int_t BufferEmpty(Int_t action=0);
   virtual void Copy(TObject &hnew) const;
   virtual Int_t Fill(Double_t x, Double_t y);
   virtual Int_t Fill(Double_t x, Double_t y, Double_t w);
   virtual Int_t Fill(Double_t x, const char *namey, Double_t w);
   virtual Int_t Fill(const char *namex, Double_t y, Double_t w);
   virtual Int_t Fill(const char *namex, const char *namey, Double_t w);
   virtual void FillN(Int_t, const Double_t *, const Double_t *, Int_t) {;} //MayNotUse
   virtual void FillN(Int_t ntimes, const Double_t *x, const Double_t *y, const Double_t *w, Int_t stride=1);
   virtual void FillRandom(const char *fname, Int_t ntimes=5000);
   virtual void FillRandom(TH1 *h, Int_t ntimes=5000);
   virtual Int_t FindFirstBinAbove(Double_t threshold=0, Int_t axis=1) const;
   virtual Int_t FindLastBinAbove (Double_t threshold=0, Int_t axis=1) const;
   virtual void FitSlicesX(TF1 *f1=0,Int_t firstybin=0, Int_t lastybin=-1, Int_t cut=0, Option_t *option="QNR", TObjArray* arr = 0); // *MENU*
   virtual void FitSlicesY(TF1 *f1=0,Int_t firstxbin=0, Int_t lastxbin=-1, Int_t cut=0, Option_t *option="QNR", TObjArray* arr = 0); // *MENU*
   virtual Double_t GetBinWithContent2(Double_t c, Int_t &binx, Int_t &biny, Int_t firstxbin=1, Int_t lastxbin=-1,Int_t firstybin=1, Int_t lastybin=-1, Double_t maxdiff=0) const;
   using TH1::GetBinErrorLow;
   using TH1::GetBinErrorUp;
   virtual Double_t GetBinErrorLow(Int_t binx, Int_t biny) { return TH1::GetBinErrorLow( GetBin(binx, biny) ); }
   virtual Double_t GetBinErrorUp(Int_t binx, Int_t biny) { return TH1::GetBinErrorUp( GetBin(binx, biny) ); }
   virtual Double_t GetCorrelationFactor(Int_t axis1=1,Int_t axis2=2) const;
   virtual Double_t GetCovariance(Int_t axis1=1,Int_t axis2=2) const;
   virtual void GetRandom2(Double_t &x, Double_t &y);
   virtual void GetStats(Double_t *stats) const;
   virtual Double_t Integral(Option_t *option="") const;
   //virtual Double_t Integral(Int_t, Int_t, Option_t * ="") const {return 0;}
   using TH1::Integral;
   virtual Double_t Integral(Int_t binx1, Int_t binx2, Int_t biny1, Int_t biny2, Option_t *option="") const;
   virtual Double_t Integral(Int_t, Int_t, Int_t, Int_t, Int_t, Int_t, Option_t * ="") const {return 0;}
   using TH1::IntegralAndError;
   virtual Double_t IntegralAndError(Int_t binx1, Int_t binx2, Int_t biny1, Int_t biny2, Double_t & err, Option_t *option="") const;
   virtual Double_t Interpolate(Double_t x);
   virtual Double_t Interpolate(Double_t x, Double_t y);
   virtual Double_t Interpolate(Double_t x, Double_t y, Double_t z);
   virtual Double_t KolmogorovTest(const TH1 *h2, Option_t *option="") const;
   virtual Long64_t Merge(TCollection *list);
   virtual TH2 *RebinX(Int_t ngroup=2, const char *newname="");
   virtual TH2 *RebinY(Int_t ngroup=2, const char *newname="");
   virtual TH2 *Rebin2D(Int_t nxgroup=2, Int_t nygroup=2, const char *newname="");
      TProfile *ProfileX(const char *name="_pfx", Int_t firstybin=1, Int_t lastybin=-1, Option_t *option="") const; // *MENU*
      TProfile *ProfileY(const char *name="_pfy", Int_t firstxbin=1, Int_t lastxbin=-1, Option_t *option="") const; // *MENU*
         TH1D *ProjectionX(const char *name="_px", Int_t firstybin=0, Int_t lastybin=-1, Option_t *option="") const; // *MENU*
         TH1D *ProjectionY(const char *name="_py", Int_t firstxbin=0, Int_t lastxbin=-1, Option_t *option="") const; // *MENU*
   virtual void PutStats(Double_t *stats);
   virtual void Reset(Option_t *option="");
   virtual void SetShowProjectionX(Int_t nbins=1); // *MENU*
   virtual void SetShowProjectionY(Int_t nbins=1); // *MENU*
   virtual TH1 *ShowBackground(Int_t niter=20, Option_t *option="same");
   virtual Int_t ShowPeaks(Double_t sigma=2, Option_t *option="", Double_t threshold=0.05); // *MENU*
   virtual void Smooth(Int_t ntimes=1, Option_t *option=""); // *MENU*

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 4; } static void Dictionary(); virtual TClass *IsA() const { return TH2::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH2::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 119; } //2-Dim histogram base class
};


//______________________________________________________________________________

class TH2C : public TH2, public TArrayC {

public:
   TH2C();
   TH2C(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                ,Int_t nbinsy,Double_t ylow,Double_t yup);
   TH2C(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,Double_t ylow,Double_t yup);
   TH2C(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                          ,Int_t nbinsy,const Double_t *ybins);
   TH2C(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,const Double_t *ybins);
   TH2C(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                          ,Int_t nbinsy,const Float_t *ybins);
   TH2C(const TH2C &h2c);
   virtual ~TH2C();
   virtual void AddBinContent(Int_t bin);
   virtual void AddBinContent(Int_t bin, Double_t w);
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t binx, Int_t biny) const {return GetBinContent(GetBin(binx,biny));}
   virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t) const {return GetBinContent(GetBin(binx,biny));}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t binx, Int_t biny, Double_t content) {SetBinContent(GetBin(binx,biny),content);}
   virtual void SetBinContent(Int_t binx, Int_t biny, Int_t, Double_t content) {SetBinContent(GetBin(binx,biny),content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH2C& operator=(const TH2C &h1);
   friend TH2C operator*(Float_t c1, TH2C &h1);
   friend TH2C operator*(TH2C &h1, Float_t c1) {return operator*(c1,h1);}
   friend TH2C operator+(TH2C &h1, TH2C &h2);
   friend TH2C operator-(TH2C &h1, TH2C &h2);
   friend TH2C operator*(TH2C &h1, TH2C &h2);
   friend TH2C operator/(TH2C &h1, TH2C &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TH2C::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH2C::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 161; } //2-Dim histograms (one char per channel)
};


//______________________________________________________________________________

class TH2S : public TH2, public TArrayS {

public:
   TH2S();
   TH2S(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                          ,Int_t nbinsy,Double_t ylow,Double_t yup);
   TH2S(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,Double_t ylow,Double_t yup);
   TH2S(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                          ,Int_t nbinsy,const Double_t *ybins);
   TH2S(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,const Double_t *ybins);
   TH2S(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                          ,Int_t nbinsy,const Float_t *ybins);
   TH2S(const TH2S &h2s);
   virtual ~TH2S();
   virtual void AddBinContent(Int_t bin);
   virtual void AddBinContent(Int_t bin, Double_t w);
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t binx, Int_t biny) const {return GetBinContent(GetBin(binx,biny));}
   virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t) const {return GetBinContent(GetBin(binx,biny));}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t binx, Int_t biny, Double_t content) {SetBinContent(GetBin(binx,biny),content);}
   virtual void SetBinContent(Int_t binx, Int_t biny, Int_t, Double_t content) {SetBinContent(GetBin(binx,biny),content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH2S& operator=(const TH2S &h1);
   friend TH2S operator*(Float_t c1, TH2S &h1);
   friend TH2S operator*(TH2S &h1, Float_t c1) {return operator*(c1,h1);}
   friend TH2S operator+(TH2S &h1, TH2S &h2);
   friend TH2S operator-(TH2S &h1, TH2S &h2);
   friend TH2S operator*(TH2S &h1, TH2S &h2);
   friend TH2S operator/(TH2S &h1, TH2S &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TH2S::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH2S::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 203; } //2-Dim histograms (one short per channel)
};


//______________________________________________________________________________

class TH2I : public TH2, public TArrayI {

public:
   TH2I();
   TH2I(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                          ,Int_t nbinsy,Double_t ylow,Double_t yup);
   TH2I(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,Double_t ylow,Double_t yup);
   TH2I(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                          ,Int_t nbinsy,const Double_t *ybins);
   TH2I(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,const Double_t *ybins);
   TH2I(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                          ,Int_t nbinsy,const Float_t *ybins);
   TH2I(const TH2I &h2i);
   virtual ~TH2I();
   virtual void AddBinContent(Int_t bin);
   virtual void AddBinContent(Int_t bin, Double_t w);
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t binx, Int_t biny) const {return GetBinContent(GetBin(binx,biny));}
   virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t) const {return GetBinContent(GetBin(binx,biny));}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t binx, Int_t biny, Double_t content) {SetBinContent(GetBin(binx,biny),content);}
   virtual void SetBinContent(Int_t binx, Int_t biny, Int_t, Double_t content) {SetBinContent(GetBin(binx,biny),content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH2I& operator=(const TH2I &h1);
   friend TH2I operator*(Float_t c1, TH2I &h1);
   friend TH2I operator*(TH2I &h1, Float_t c1) {return operator*(c1,h1);}
   friend TH2I operator+(TH2I &h1, TH2I &h2);
   friend TH2I operator-(TH2I &h1, TH2I &h2);
   friend TH2I operator*(TH2I &h1, TH2I &h2);
   friend TH2I operator/(TH2I &h1, TH2I &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TH2I::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH2I::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 245; } //2-Dim histograms (one 32 bits integer per channel)
};


//______________________________________________________________________________

class TH2F : public TH2, public TArrayF {

public:
   TH2F();
   TH2F(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                          ,Int_t nbinsy,Double_t ylow,Double_t yup);
   TH2F(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,Double_t ylow,Double_t yup);
   TH2F(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                          ,Int_t nbinsy,const Double_t *ybins);
   TH2F(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,const Double_t *ybins);
   TH2F(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                          ,Int_t nbinsy,const Float_t *ybins);
   TH2F(const TMatrixFBase &m);
   TH2F(const TH2F &h2f);
   virtual ~TH2F();
   virtual void AddBinContent(Int_t bin) {++fArray[bin];}
   virtual void AddBinContent(Int_t bin, Double_t w)
                                 {fArray[bin] += Float_t (w);}
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t binx, Int_t biny) const {return GetBinContent(GetBin(binx,biny));}
   virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t) const {return GetBinContent(GetBin(binx,biny));}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t binx, Int_t biny, Double_t content) {SetBinContent(GetBin(binx,biny),content);}
   virtual void SetBinContent(Int_t binx, Int_t biny, Int_t, Double_t content) {SetBinContent(GetBin(binx,biny),content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH2F& operator=(const TH2F &h1);
   friend TH2F operator*(Float_t c1, TH2F &h1);
   friend TH2F operator*(TH2F &h1, Float_t c1);
   friend TH2F operator+(TH2F &h1, TH2F &h2);
   friend TH2F operator-(TH2F &h1, TH2F &h2);
   friend TH2F operator*(TH2F &h1, TH2F &h2);
   friend TH2F operator/(TH2F &h1, TH2F &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TH2F::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH2F::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 289; } //2-Dim histograms (one float per channel)
};


//______________________________________________________________________________

class TH2D : public TH2, public TArrayD {

public:
   TH2D();
   TH2D(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                          ,Int_t nbinsy,Double_t ylow,Double_t yup);
   TH2D(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,Double_t ylow,Double_t yup);
   TH2D(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                          ,Int_t nbinsy,const Double_t *ybins);
   TH2D(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,const Double_t *ybins);
   TH2D(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                          ,Int_t nbinsy,const Float_t *ybins);
   TH2D(const TMatrixDBase &m);
   TH2D(const TH2D &h2d);
   virtual ~TH2D();
   virtual void AddBinContent(Int_t bin) {++fArray[bin];}
   virtual void AddBinContent(Int_t bin, Double_t w)
                                 {fArray[bin] += Double_t (w);}
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t binx, Int_t biny) const {return GetBinContent(GetBin(binx,biny));}
   virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t) const {return GetBinContent(GetBin(binx,biny));}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t binx, Int_t biny, Double_t content) {SetBinContent(GetBin(binx,biny),content);}
   virtual void SetBinContent(Int_t binx, Int_t biny, Int_t, Double_t content) {SetBinContent(GetBin(binx,biny),content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH2D& operator=(const TH2D &h1);
   friend TH2D operator*(Float_t c1, TH2D &h1);
   friend TH2D operator*(TH2D &h1, Float_t c1) {return operator*(c1,h1);}
   friend TH2D operator+(TH2D &h1, TH2D &h2);
   friend TH2D operator-(TH2D &h1, TH2D &h2);
   friend TH2D operator*(TH2D &h1, TH2D &h2);
   friend TH2D operator/(TH2D &h1, TH2D &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TH2D::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH2D::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 333; } //2-Dim histograms (one double per channel)
};
# 6 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h" 1
// @(#)root/hist:$Id: TH3.h 44515 2012-06-04 14:16:56Z moneta $
// Author: Rene Brun   27/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TH3                                                                  //
//                                                                      //
// 3-Dim histogram base class.                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////






# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAtt3D.h" 1
// @(#)root/base:$Id: TAtt3D.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Fons Rademakers   08/09/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TAtt3D                                                               //
//                                                                      //
// Use this attribute class when an object should have 3D capabilities. //
//                                                                      //
//////////////////////////////////////////////////////////////////////////






class TAtt3D {

public:
   TAtt3D() { }
   virtual ~TAtt3D() { }

   virtual void Sizeof3D() const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TAtt3D::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TAtt3D::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAtt3D.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 37; } //3D attributes
};
# 30 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h" 2


class TH2D;
class TProfile2D;

class TH3 : public TH1, public TAtt3D {

protected:
   Double_t fTsumwy; //Total Sum of weight*Y
   Double_t fTsumwy2; //Total Sum of weight*Y*Y
   Double_t fTsumwxy; //Total Sum of weight*X*Y
   Double_t fTsumwz; //Total Sum of weight*Z
   Double_t fTsumwz2; //Total Sum of weight*Z*Z
   Double_t fTsumwxz; //Total Sum of weight*X*Z
   Double_t fTsumwyz; //Total Sum of weight*Y*Z

   TH3();
   TH3(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                  ,Int_t nbinsy,Double_t ylow,Double_t yup
                                  ,Int_t nbinsz,Double_t zlow,Double_t zup);
   TH3(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                         ,Int_t nbinsy,const Float_t *ybins
                                         ,Int_t nbinsz,const Float_t *zbins);
   TH3(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                         ,Int_t nbinsy,const Double_t *ybins
                                         ,Int_t nbinsz,const Double_t *zbins);
   virtual Int_t BufferFill(Double_t x, Double_t y, Double_t z, Double_t w);

   void DoFillProfileProjection(TProfile2D * p2, const TAxis & a1, const TAxis & a2, const TAxis & a3, Int_t bin1, Int_t bin2, Int_t bin3, Int_t inBin, Bool_t useWeights) const;

   virtual Int_t BufferFill(Double_t, Double_t) {return -2;} //may not use
   virtual Int_t BufferFill(Double_t, Double_t, Double_t) {return -2;} //may not use
   Int_t Fill(Double_t); //MayNotUse
   Int_t Fill(Double_t,Double_t) {return Fill(0.);} //MayNotUse
   Int_t Fill(const char*, Double_t) {return Fill(0);} //MayNotUse
   Int_t Fill(Double_t,const char*,Double_t) {return Fill(0);} //MayNotUse
   Int_t Fill(const char*,Double_t,Double_t) {return Fill(0);} //MayNotUse
   Int_t Fill(const char*,const char*,Double_t) {return Fill(0);} //MayNotUse

public:
   TH3(const TH3&);
   virtual ~TH3();
   virtual Int_t BufferEmpty(Int_t action=0);
   virtual void Copy(TObject &hnew) const;
   virtual Int_t Fill(Double_t x, Double_t y, Double_t z);
   virtual Int_t Fill(Double_t x, Double_t y, Double_t z, Double_t w);

   virtual Int_t Fill(const char *namex, const char *namey, const char *namez, Double_t w);
   virtual Int_t Fill(const char *namex, Double_t y, const char *namez, Double_t w);
   virtual Int_t Fill(const char *namex, const char *namey, Double_t z, Double_t w);
   virtual Int_t Fill(Double_t x, const char *namey, const char *namez, Double_t w);
   virtual Int_t Fill(Double_t x, const char *namey, Double_t z, Double_t w);
   virtual Int_t Fill(Double_t x, Double_t y, const char *namez, Double_t w);

   virtual void FillRandom(const char *fname, Int_t ntimes=5000);
   virtual void FillRandom(TH1 *h, Int_t ntimes=5000);
   virtual Int_t FindFirstBinAbove(Double_t threshold=0, Int_t axis=1) const;
   virtual Int_t FindLastBinAbove (Double_t threshold=0, Int_t axis=1) const;
   virtual void FitSlicesZ(TF1 *f1=0,Int_t binminx=1, Int_t binmaxx=0,Int_t binminy=1, Int_t binmaxy=0,
                                        Int_t cut=0 ,Option_t *option="QNR"); // *MENU*
   using TH1::GetBinErrorLow;
   using TH1::GetBinErrorUp;
   virtual Double_t GetBinErrorLow(Int_t binx, Int_t biny, Int_t binz) { return TH1::GetBinErrorLow( GetBin(binx, biny, binz) ); }
   virtual Double_t GetBinErrorUp(Int_t binx, Int_t biny, Int_t binz) { return TH1::GetBinErrorUp( GetBin(binx, biny, binz) ); }
   virtual Double_t GetBinWithContent3(Double_t c, Int_t &binx, Int_t &biny, Int_t &binz, Int_t firstx=0, Int_t lastx=0,Int_t firsty=0, Int_t lasty=0, Int_t firstz=0, Int_t lastz=0, Double_t maxdiff=0) const;
   virtual Double_t GetCorrelationFactor(Int_t axis1=1,Int_t axis2=2) const;
   virtual Double_t GetCovariance(Int_t axis1=1,Int_t axis2=2) const;
   virtual void GetRandom3(Double_t &x, Double_t &y, Double_t &z);
   virtual void GetStats(Double_t *stats) const;
   virtual Double_t Integral(Option_t *option="") const;
   using TH1::Integral;
   virtual Double_t Integral(Int_t binx1, Int_t binx2, Int_t biny1, Int_t biny2, Int_t binz1, Int_t binz2, Option_t *option="") const;
   using TH1::IntegralAndError;
   virtual Double_t IntegralAndError(Int_t binx1, Int_t binx2, Int_t biny1, Int_t biny2, Int_t binz1, Int_t binz2, Double_t & err, Option_t *option="") const;
   virtual Double_t Interpolate(Double_t x);
   virtual Double_t Interpolate(Double_t x, Double_t y);
   virtual Double_t Interpolate(Double_t x, Double_t y, Double_t z);
   virtual Double_t KolmogorovTest(const TH1 *h2, Option_t *option="") const;
   virtual Long64_t Merge(TCollection *list);
         TH1D *ProjectionX(const char *name="_px", Int_t firstybin=0, Int_t lastybin=-1, Int_t firstzbin=0,
                                Int_t lastzbin=-1, Option_t *option="") const; // *MENU*
         TH1D *ProjectionY(const char *name="_py", Int_t firstxbin=0, Int_t lastxbin=-1, Int_t firstzbin=0,
                                Int_t lastzbin=-1, Option_t *option="") const; // *MENU*
         TH1D *ProjectionZ(const char *name="_pz", Int_t firstxbin=0, Int_t lastxbin=-1, Int_t firstybin=0,
                                Int_t lastybin=-1, Option_t *option="") const; // *MENU*
         TH1 *Project3D(Option_t *option="x") const; // *MENU*
   TProfile2D *Project3DProfile(Option_t *option="xy") const; // *MENU*
   virtual void PutStats(Double_t *stats);
   virtual TH3 *RebinX(Int_t ngroup = 2, const char *newname = "");
   virtual TH3 *RebinY(Int_t ngroup = 2, const char *newname = "");
   virtual TH3 *RebinZ(Int_t ngroup = 2, const char *newname = "");
   virtual TH3 *Rebin3D(Int_t nxgroup = 2, Int_t nygroup = 2, Int_t nzgroup = 2, const char *newname = "");
   virtual void Reset(Option_t *option="");
   virtual void SetShowProjection(const char *option="xy",Int_t nbins=1); // *MENU*

protected:
   TH1D *DoProject1D(const char* name, const char * title, TAxis* projX,
                         bool computeErrors, bool originalRange,
                         bool useUF, bool useOF) const;
   TH2D *DoProject2D(const char* name, const char * title, TAxis* projX, TAxis* projY,
                        bool computeErrors, bool originalRange,
                         bool useUF, bool useOF) const;
   TProfile2D *DoProjectProfile2D(const char* name, const char * title, TAxis* projX, TAxis* projY,
                                        bool originalRange, bool useUF, bool useOF) const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 5; } static void Dictionary(); virtual TClass *IsA() const { return TH3::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH3::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 135; } //3-Dim histogram base class
};

//________________________________________________________________________

class TH3C : public TH3, public TArrayC {
public:
   TH3C();
   TH3C(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                  ,Int_t nbinsy,Double_t ylow,Double_t yup
                                  ,Int_t nbinsz,Double_t zlow,Double_t zup);
   TH3C(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                          ,Int_t nbinsy,const Float_t *ybins
                                          ,Int_t nbinsz,const Float_t *zbins);
   TH3C(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,const Double_t *ybins
                                          ,Int_t nbinsz,const Double_t *zbins);
   TH3C(const TH3C &h3c);
   virtual ~TH3C();
   virtual void AddBinContent(Int_t bin);
   virtual void AddBinContent(Int_t bin, Double_t w);
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const ;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t bin, Int_t) const {return GetBinContent(bin);}
   virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t binz) const {return GetBinContent(GetBin(binx,biny,binz));}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t bin, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinContent(Int_t binx, Int_t biny, Int_t binz, Double_t content) {SetBinContent(GetBin(binx,biny,binz),content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH3C& operator=(const TH3C &h1);
   friend TH3C operator*(Float_t c1, TH3C &h1);
   friend TH3C operator*(TH3C &h1, Float_t c1) {return operator*(c1,h1);}
   friend TH3C operator+(TH3C &h1, TH3C &h2);
   friend TH3C operator-(TH3C &h1, TH3C &h2);
   friend TH3C operator*(TH3C &h1, TH3C &h2);
   friend TH3C operator/(TH3C &h1, TH3C &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TH3C::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH3C::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 174; } //3-Dim histograms (one char per channel)
};

//________________________________________________________________________

class TH3S : public TH3, public TArrayS {
public:
   TH3S();
   TH3S(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                  ,Int_t nbinsy,Double_t ylow,Double_t yup
                                  ,Int_t nbinsz,Double_t zlow,Double_t zup);
   TH3S(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                          ,Int_t nbinsy,const Float_t *ybins
                                          ,Int_t nbinsz,const Float_t *zbins);
   TH3S(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,const Double_t *ybins
                                          ,Int_t nbinsz,const Double_t *zbins);
   TH3S(const TH3S &h3s);
   virtual ~TH3S();
   virtual void AddBinContent(Int_t bin);
   virtual void AddBinContent(Int_t bin, Double_t w);
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t bin, Int_t) const {return GetBinContent(bin);}
   virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t binz) const {return GetBinContent(GetBin(binx,biny,binz));}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t bin, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinContent(Int_t binx, Int_t biny, Int_t binz, Double_t content) {SetBinContent(GetBin(binx,biny,binz),content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH3S& operator=(const TH3S &h1);
   friend TH3S operator*(Float_t c1, TH3S &h1);
   friend TH3S operator*(TH3S &h1, Float_t c1) {return operator*(c1,h1);}
   friend TH3S operator+(TH3S &h1, TH3S &h2);
   friend TH3S operator-(TH3S &h1, TH3S &h2);
   friend TH3S operator*(TH3S &h1, TH3S &h2);
   friend TH3S operator/(TH3S &h1, TH3S &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TH3S::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH3S::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 213; } //3-Dim histograms (one short per channel)
};

//________________________________________________________________________

class TH3I : public TH3, public TArrayI {
public:
   TH3I();
   TH3I(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                  ,Int_t nbinsy,Double_t ylow,Double_t yup
                                  ,Int_t nbinsz,Double_t zlow,Double_t zup);
   TH3I(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                          ,Int_t nbinsy,const Float_t *ybins
                                          ,Int_t nbinsz,const Float_t *zbins);
   TH3I(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,const Double_t *ybins
                                          ,Int_t nbinsz,const Double_t *zbins);
   TH3I(const TH3I &h3i);
   virtual ~TH3I();
   virtual void AddBinContent(Int_t bin);
   virtual void AddBinContent(Int_t bin, Double_t w);
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t bin, Int_t) const {return GetBinContent(bin);}
   virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t binz) const {return GetBinContent(GetBin(binx,biny,binz));}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t bin, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinContent(Int_t binx, Int_t biny, Int_t binz, Double_t content) {SetBinContent(GetBin(binx,biny,binz),content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH3I& operator=(const TH3I &h1);
   friend TH3I operator*(Float_t c1, TH3I &h1);
   friend TH3I operator*(TH3I &h1, Float_t c1) {return operator*(c1,h1);}
   friend TH3I operator+(TH3I &h1, TH3I &h2);
   friend TH3I operator-(TH3I &h1, TH3I &h2);
   friend TH3I operator*(TH3I &h1, TH3I &h2);
   friend TH3I operator/(TH3I &h1, TH3I &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TH3I::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH3I::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 252; } //3-Dim histograms (one 32 bits integer per channel)
};


//________________________________________________________________________

class TH3F : public TH3, public TArrayF {
public:
   TH3F();
   TH3F(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                  ,Int_t nbinsy,Double_t ylow,Double_t yup
                                  ,Int_t nbinsz,Double_t zlow,Double_t zup);
   TH3F(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                          ,Int_t nbinsy,const Float_t *ybins
                                          ,Int_t nbinsz,const Float_t *zbins);
   TH3F(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,const Double_t *ybins
                                          ,Int_t nbinsz,const Double_t *zbins);
   TH3F(const TH3F &h3f);
   virtual ~TH3F();
   virtual void AddBinContent(Int_t bin) {++fArray[bin];}
   virtual void AddBinContent(Int_t bin, Double_t w)
                                 {fArray[bin] += Float_t (w);}
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t bin, Int_t) const {return GetBinContent(bin);}
   virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t binz) const {return GetBinContent(GetBin(binx,biny,binz));}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t bin, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinContent(Int_t binx, Int_t biny, Int_t binz, Double_t content) {SetBinContent(GetBin(binx,biny,binz),content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH3F& operator=(const TH3F &h1);
   friend TH3F operator*(Float_t c1, TH3F &h1);
   friend TH3F operator*(TH3F &h1, Float_t c1) {return operator*(c1,h1);}
   friend TH3F operator+(TH3F &h1, TH3F &h2);
   friend TH3F operator-(TH3F &h1, TH3F &h2);
   friend TH3F operator*(TH3F &h1, TH3F &h2);
   friend TH3F operator/(TH3F &h1, TH3F &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TH3F::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH3F::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 293; } //3-Dim histograms (one float per channel)
};

//________________________________________________________________________

class TH3D : public TH3, public TArrayD {
public:
   TH3D();
   TH3D(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                  ,Int_t nbinsy,Double_t ylow,Double_t yup
                                  ,Int_t nbinsz,Double_t zlow,Double_t zup);
   TH3D(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                          ,Int_t nbinsy,const Float_t *ybins
                                          ,Int_t nbinsz,const Float_t *zbins);
   TH3D(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                          ,Int_t nbinsy,const Double_t *ybins
                                          ,Int_t nbinsz,const Double_t *zbins);
   TH3D(const TH3D &h3d);
   virtual ~TH3D();
   virtual void AddBinContent(Int_t bin) {++fArray[bin];}
   virtual void AddBinContent(Int_t bin, Double_t w)
                                 {fArray[bin] += Double_t (w);}
   virtual void Copy(TObject &hnew) const;
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t bin, Int_t) const {return GetBinContent(bin);}
   virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t binz) const {return GetBinContent(GetBin(binx,biny,binz));}
   virtual void Reset(Option_t *option="");
   virtual void SetBinContent(Int_t bin, Double_t content);
   virtual void SetBinContent(Int_t bin, Int_t, Double_t content) {SetBinContent(bin,content);}
   virtual void SetBinContent(Int_t binx, Int_t biny, Int_t binz, Double_t content) {SetBinContent(GetBin(binx,biny,binz),content);}
   virtual void SetBinsLength(Int_t n=-1);
           TH3D& operator=(const TH3D &h1);
   friend TH3D operator*(Float_t c1, TH3D &h1);
   friend TH3D operator*(TH3D &h1, Float_t c1) {return operator*(c1,h1);}
   friend TH3D operator+(TH3D &h1, TH3D &h2);
   friend TH3D operator-(TH3D &h1, TH3D &h2);
   friend TH3D operator*(TH3D &h1, TH3D &h2);
   friend TH3D operator/(TH3D &h1, TH3D &h2);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TH3D::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TH3D::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 333; } //3-Dim histograms (one double per channel)
};
# 7 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph.h" 1
// @(#)root/hist:$Id: TGraph.h 38549 2011-03-21 19:26:04Z pcanal $
// Author: Rene Brun, Olivier Couet   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGraph                                                               //
//                                                                      //
// Graph graphics class.                                                //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 43 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph.h"
class TBrowser;
class TAxis;
class TH1;
class TH1F;
class TCollection;
class TF1;
class TSpline;

# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFitResultPtr.h" 1
// @(#)root/mathcore:$Id: TFitResultPtr.h 31262 2009-11-18 07:38:37Z brun $
// Author: David Gonzalez Maline Tue Nov 10 15:01:24 2009

/*************************************************************************
 * Copyright (C) 1995-2009, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 52 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph.h" 2

class TGraph : public TNamed, public TAttLine, public TAttFill, public TAttMarker {

protected:

   Int_t fMaxSize; //!Current dimension of arrays fX and fY
   Int_t fNpoints; //Number of points <= fMaxSize
   Double_t *fX; //[fNpoints] array of X points
   Double_t *fY; //[fNpoints] array of Y points
   TList *fFunctions; //Pointer to list of functions (fits and user)
   TH1F *fHistogram; //Pointer to histogram used for drawing axis
   Double_t fMinimum; //Minimum value for plotting along y
   Double_t fMaximum; //Maximum value for plotting along y

   static void SwapValues(Double_t* arr, Int_t pos1, Int_t pos2);
   virtual void SwapPoints(Int_t pos1, Int_t pos2);

   virtual Double_t **Allocate(Int_t newsize);
   Double_t **AllocateArrays(Int_t Narrays, Int_t arraySize);
   virtual Bool_t CopyPoints(Double_t **newarrays, Int_t ibegin, Int_t iend, Int_t obegin);
   virtual void CopyAndRelease(Double_t **newarrays, Int_t ibegin, Int_t iend, Int_t obegin);
   Bool_t CtorAllocate();
   Double_t **ExpandAndCopy(Int_t size, Int_t iend);
   virtual void FillZero(Int_t begin, Int_t end, Bool_t from_ctor = kTRUE);
   Double_t **ShrinkAndCopy(Int_t size, Int_t iend);

public:
   // TGraph status bits
   enum {
      kClipFrame = (1ULL << (10)), // clip to the frame boundary
      kNotEditable = (1ULL << (18)) // bit set if graph is non editable
   };

   TGraph();
   TGraph(Int_t n);
   TGraph(Int_t n, const Int_t *x, const Int_t *y);
   TGraph(Int_t n, const Float_t *x, const Float_t *y);
   TGraph(Int_t n, const Double_t *x, const Double_t *y);
   TGraph(const TGraph &gr);
   TGraph& operator=(const TGraph&);
   TGraph(const TVectorF &vx, const TVectorF &vy);
   TGraph(const TVectorD &vx, const TVectorD &vy);
   TGraph(const TH1 *h);
   TGraph(const TF1 *f, Option_t *option="");
   TGraph(const char *filename, const char *format="%lg %lg", Option_t *option="");
   virtual ~TGraph();

   virtual void Apply(TF1 *f);
   virtual void Browse(TBrowser *b);
   virtual Double_t Chisquare(const TF1 *f1) const;
   static Bool_t CompareArg(const TGraph* gr, Int_t left, Int_t right);
   static Bool_t CompareX(const TGraph* gr, Int_t left, Int_t right);
   static Bool_t CompareY(const TGraph* gr, Int_t left, Int_t right);
   static Bool_t CompareRadius(const TGraph* gr, Int_t left, Int_t right);
   virtual void ComputeRange(Double_t &xmin, Double_t &ymin, Double_t &xmax, Double_t &ymax) const;
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual void Draw(Option_t *chopt="");
   virtual void DrawGraph(Int_t n, const Int_t *x, const Int_t *y, Option_t *option="");
   virtual void DrawGraph(Int_t n, const Float_t *x, const Float_t *y, Option_t *option="");
   virtual void DrawGraph(Int_t n, const Double_t *x=0, const Double_t *y=0, Option_t *option="");
   virtual void DrawPanel(); // *MENU*
   virtual Double_t Eval(Double_t x, TSpline *spline=0, Option_t *option="") const;
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   virtual void Expand(Int_t newsize);
   virtual void Expand(Int_t newsize, Int_t step);
   virtual TObject *FindObject(const char *name) const;
   virtual TObject *FindObject(const TObject *obj) const;
   virtual TFitResultPtr Fit(const char *formula ,Option_t *option="" ,Option_t *goption="", Axis_t xmin=0, Axis_t xmax=0); // *MENU*
   virtual TFitResultPtr Fit(TF1 *f1 ,Option_t *option="" ,Option_t *goption="", Axis_t xmin=0, Axis_t xmax=0);
   virtual void FitPanel(); // *MENU*
   Bool_t GetEditable() const;
   TF1 *GetFunction(const char *name) const;
   TH1F *GetHistogram() const;
   TList *GetListOfFunctions() const { return fFunctions; }
   virtual Double_t GetCorrelationFactor() const;
   virtual Double_t GetCovariance() const;
   virtual Double_t GetMean(Int_t axis=1) const;
   virtual Double_t GetRMS(Int_t axis=1) const;
   Int_t GetMaxSize() const {return fMaxSize;}
   Int_t GetN() const {return fNpoints;}
   virtual Double_t GetErrorX(Int_t bin) const;
   virtual Double_t GetErrorY(Int_t bin) const;
   virtual Double_t GetErrorXhigh(Int_t bin) const;
   virtual Double_t GetErrorXlow(Int_t bin) const;
   virtual Double_t GetErrorYhigh(Int_t bin) const;
   virtual Double_t GetErrorYlow(Int_t bin) const;
   Double_t *GetX() const {return fX;}
   Double_t *GetY() const {return fY;}
   virtual Double_t *GetEX() const {return 0;}
   virtual Double_t *GetEY() const {return 0;}
   virtual Double_t *GetEXhigh() const {return 0;}
   virtual Double_t *GetEXlow() const {return 0;}
   virtual Double_t *GetEYhigh() const {return 0;}
   virtual Double_t *GetEYlow() const {return 0;}
   virtual Double_t *GetEXlowd() const {return 0;}
   virtual Double_t *GetEXhighd() const {return 0;}
   virtual Double_t *GetEYlowd() const {return 0;}
   virtual Double_t *GetEYhighd() const {return 0;}
   Double_t GetMaximum() const {return fMaximum;}
   Double_t GetMinimum() const {return fMinimum;}
   TAxis *GetXaxis() const ;
   TAxis *GetYaxis() const ;
   virtual Int_t GetPoint(Int_t i, Double_t &x, Double_t &y) const;

   virtual void InitExpo(Double_t xmin=0, Double_t xmax=0);
   virtual void InitGaus(Double_t xmin=0, Double_t xmax=0);
   virtual void InitPolynom(Double_t xmin=0, Double_t xmax=0);
   virtual Int_t InsertPoint(); // *MENU*
   virtual Double_t Integral(Int_t first=0, Int_t last=-1) const;
   virtual Bool_t IsEditable() const {return !TestBit(kNotEditable);}
   virtual Int_t IsInside(Double_t x, Double_t y) const;
   virtual void LeastSquareFit(Int_t m, Double_t *a, Double_t xmin=0, Double_t xmax=0);
   virtual void LeastSquareLinearFit(Int_t n, Double_t &a0, Double_t &a1, Int_t &ifail, Double_t xmin=0, Double_t xmax=0);
   virtual Int_t Merge(TCollection* list);
   virtual void Paint(Option_t *chopt="");
   void PaintGraph(Int_t npoints, const Double_t *x, const Double_t *y, Option_t *chopt);
   void PaintGrapHist(Int_t npoints, const Double_t *x, const Double_t *y, Option_t *chopt);
   virtual void PaintStats(TF1 *fit);
   virtual void Print(Option_t *chopt="") const;
   virtual void RecursiveRemove(TObject *obj);
   virtual Int_t RemovePoint(); // *MENU*
   virtual Int_t RemovePoint(Int_t ipoint);
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetEditable(Bool_t editable=kTRUE); // *TOGGLE* *GETTER=GetEditable
   virtual void SetHistogram(TH1F *h) {fHistogram = h;}
   virtual void SetMaximum(Double_t maximum=-1111); // *MENU*
   virtual void SetMinimum(Double_t minimum=-1111); // *MENU*
   virtual void Set(Int_t n);
   virtual void SetPoint(Int_t i, Double_t x, Double_t y);
   virtual void SetTitle(const char *title=""); // *MENU*
   virtual void Sort(Bool_t (*greater)(const TGraph*, Int_t, Int_t)=&TGraph::CompareX,
                              Bool_t ascending=kTRUE, Int_t low=0, Int_t high=-1111);
   virtual void UseCurrentStyle();
   void Zero(Int_t &k,Double_t AZ,Double_t BZ,Double_t E2,Double_t &X,Double_t &Y,Int_t maxiterations);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 4; } static void Dictionary(); virtual TClass *IsA() const { return TGraph::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TGraph::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 187; } //Graph graphics class
};

inline Double_t **TGraph::Allocate(Int_t newsize) {
   return AllocateArrays(2, newsize);
}
# 8 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph2D.h" 1
// @(#)root/hist:$Id: TGraph2D.h,v 1.00
// Author: Olivier Couet

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGraph2D                                                             //
//                                                                      //
// Graph 2D graphics class.                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualHistPainter.h" 1
// @(#)root/hist:$Id: TVirtualHistPainter.h 25487 2008-09-22 12:44:13Z moneta $
// Author: Rene Brun   30/08/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TVirtualHistPainter                                                  //
//                                                                      //
// Abstract base class for Histogram painters                           //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TClass;
class TH1;
class TF1;
class TList;

class TVirtualHistPainter : public TObject {

private:
   static TClass *fgPainter; //Pointer to class painter

public:
   TVirtualHistPainter() { }
   virtual ~TVirtualHistPainter() { }
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py) = 0;
   virtual void DrawPanel() = 0;
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py) = 0;
   virtual TList *GetContourList(Double_t contour) const = 0;
   virtual char *GetObjectInfo(Int_t px, Int_t py) const = 0;
   virtual TList *GetStack() const = 0;
   virtual Bool_t IsInside(Int_t x, Int_t y) = 0;
   virtual Bool_t IsInside(Double_t x, Double_t y) = 0;
   virtual void Paint(Option_t *option="") = 0;
   virtual void PaintStat(Int_t dostat, TF1 *fit) = 0;
   virtual void ProcessMessage(const char *mess, const TObject *obj) = 0;
   virtual void SetHistogram(TH1 *h) = 0;
   virtual void SetStack(TList *stack) = 0;
   virtual Int_t MakeCuts(char *cutsopt) = 0;
   virtual void SetShowProjection(const char *option, Int_t nbins) = 0;

   static TVirtualHistPainter *HistPainter(TH1 *obj);
   static void SetPainter(const char *painter);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TVirtualHistPainter::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TVirtualHistPainter::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualHistPainter.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 59; } //Abstract interface for histogram painters
};
# 29 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph2D.h" 2
# 40 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph2D.h"
class TAxis;
class TList;
class TF2;
class TH2;
class TH2D;
class TView;
class TDirectory;

# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFitResultPtr.h" 1
// @(#)root/mathcore:$Id: TFitResultPtr.h 31262 2009-11-18 07:38:37Z brun $
// Author: David Gonzalez Maline Tue Nov 10 15:01:24 2009

/*************************************************************************
 * Copyright (C) 1995-2009, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 49 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph2D.h" 2

class TGraph2D : public TNamed, public TAttLine, public TAttFill, public TAttMarker {

protected:

   Int_t fNpoints; // Number of points in the data set
   Int_t fNpx; // Number of bins along X in fHistogram
   Int_t fNpy; // Number of bins along Y in fHistogram
   Int_t fMaxIter; // Maximum number of iterations to find Delaunay t>
   Int_t fSize; //!Real size of fX, fY and fZ
   Double_t *fX; //[fNpoints]
   Double_t *fY; //[fNpoints] Data set to be plotted
   Double_t *fZ; //[fNpoints]
   Double_t fMinimum; // Minimum value for plotting along z
   Double_t fMaximum; // Maximum value for plotting along z
   Double_t fMargin; // Extra space (in %) around interpolated area for fHistogram
   Double_t fZout; // fHistogram bin height for points lying outside the interpolated area
   TList *fFunctions; // Pointer to list of functions (fits and user)
   TH2D *fHistogram; //!2D histogram of z values linearly interpolated
   TDirectory *fDirectory; //!Pointer to directory holding this 2D graph
   TVirtualHistPainter *fPainter; //!pointer to histogram painter

   void Build(Int_t n);

private:

   Bool_t fUserHisto; // True when SetHistogram has been called

protected:

public:

   TGraph2D();
   TGraph2D(Int_t n);
   TGraph2D(Int_t n, Int_t *x, Int_t *y, Int_t *z);
   TGraph2D(Int_t n, Float_t *x, Float_t *y, Float_t *z);
   TGraph2D(Int_t n, Double_t *x, Double_t *y, Double_t *z);
   TGraph2D(TH2 *h2);
   TGraph2D(const char *name, const char *title, Int_t n, Double_t *x, Double_t *y, Double_t *z);
   TGraph2D(const char *filename, const char *format="%lg %lg %lg", Option_t *option="");
   TGraph2D(const TGraph2D &);

   virtual ~TGraph2D();

   TGraph2D& operator=(const TGraph2D &);

   virtual void Clear(Option_t *option="");
   virtual void DirectoryAutoAdd(TDirectory *);
   Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual void Draw(Option_t *option="");
   void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   virtual TObject *FindObject(const char *name) const;
   virtual TObject *FindObject(const TObject *obj) const;
   virtual TFitResultPtr Fit(const char *formula ,Option_t *option="" ,Option_t *goption=""); // *MENU*
   virtual TFitResultPtr Fit(TF2 *f2 ,Option_t *option="" ,Option_t *goption=""); // *MENU*
   virtual void FitPanel(); // *MENU*
   TList *GetContourList(Double_t contour);
   TDirectory *GetDirectory() const {return fDirectory;}
   Int_t GetNpx() const {return fNpx;}
   Int_t GetNpy() const {return fNpy;}
   TH2D *GetHistogram(Option_t *option="");
   TList *GetListOfFunctions() const { return fFunctions; }
   virtual Double_t GetErrorX(Int_t bin) const;
   virtual Double_t GetErrorY(Int_t bin) const;
   virtual Double_t GetErrorZ(Int_t bin) const;
   Double_t GetMargin() const {return fMargin;}
   TAxis *GetXaxis() const ;
   TAxis *GetYaxis() const ;
   TAxis *GetZaxis() const ;
   Int_t GetN() const {return fNpoints;}
   Double_t *GetX() const {return fX;}
   Double_t *GetY() const {return fY;}
   Double_t *GetZ() const {return fZ;}
   virtual Double_t *GetEX() const {return 0;}
   virtual Double_t *GetEY() const {return 0;}
   virtual Double_t *GetEZ() const {return 0;}
   Double_t GetXmax() const;
   Double_t GetXmin() const;
   Double_t GetYmax() const;
   Double_t GetYmin() const;
   Double_t GetZmax() const;
   Double_t GetZmin() const;
   virtual Double_t GetXmaxE() const {return GetXmax();};
   virtual Double_t GetXminE() const {return GetXmin();};
   virtual Double_t GetYmaxE() const {return GetYmax();};
   virtual Double_t GetYminE() const {return GetYmin();};
   virtual Double_t GetZmaxE() const {return GetZmax();};
   virtual Double_t GetZminE() const {return GetZmin();};
   Double_t Interpolate(Double_t x, Double_t y);
   void Paint(Option_t *option="");
   TH1 *Project(Option_t *option="x") const; // *MENU*
   Int_t RemovePoint(Int_t ipoint); // *MENU*
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void Set(Int_t n);
   virtual void SetDirectory(TDirectory *dir);
   virtual void SetHistogram(TH2 *h);
   void SetMargin(Double_t m=0.1); // *MENU*
   void SetMarginBinsContent(Double_t z=0.); // *MENU*
   void SetMaximum(Double_t maximum=-1111); // *MENU*
   void SetMinimum(Double_t minimum=-1111); // *MENU*
   void SetMaxIter(Int_t n=100000) {fMaxIter = n;} // *MENU*
   virtual void SetName(const char *name); // *MENU*
   virtual void SetNameTitle(const char *name, const char *title);
   void SetNpx(Int_t npx=40); // *MENU*
   void SetNpy(Int_t npx=40); // *MENU*
   virtual void SetPoint(Int_t point, Double_t x, Double_t y, Double_t z); // *MENU*
   virtual void SetTitle(const char *title=""); // *MENU*

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TGraph2D::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TGraph2D::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph2D.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 157; } //Set of n x[i],y[i],z[i] points with 3-d graphics including Delaunay triangulation
};
# 9 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 1
// @(#)root/tree:$Id: TNtuple.h 41666 2011-10-31 19:10:37Z pcanal $
// Author: Rene Brun   06/04/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TNtuple                                                              //
//                                                                      //
// A simple tree with branches of floats.                               //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h" 1
// @(#)root/tree:$Id: TTree.h 44280 2012-05-18 06:05:10Z pcanal $
// Author: Rene Brun   12/01/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TTree                                                                //
//                                                                      //
// A TTree object is a list of TBranch.                                 //
//   To Create a TTree object one must:                                 //
//    - Create the TTree header via the TTree constructor               //
//    - Call the TBranch constructor for every branch.                  //
//                                                                      //
//   To Fill this object, use member function Fill with no parameters.  //
//     The Fill function loops on all defined TBranch.                  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBranch.h" 1
// @(#)root/tree:$Id: TBranch.h 40872 2011-09-13 21:33:33Z pcanal $
// Author: Rene Brun   12/01/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TBranch                                                              //
//                                                                      //
// A TTree object is a list of TBranchs.                                //
//   A TBranch describes the branch data structure and supports :       //
//     the list of TBaskets (branch buffers) associated to this branch. //
//     the list of TLeaves (branch description)                         //
//////////////////////////////////////////////////////////////////////////
# 40 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBranch.h"
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDataType.h" 1
// @(#)root/meta:$Id: TDataType.h 41070 2011-09-30 12:15:22Z axel $
// Author: Rene Brun   04/02/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TDataType                                                            //
//                                                                      //
// Basic data type descriptor (datatype information is obtained from    //
// CINT).                                                               //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDictionary.h" 1
// @(#)root/meta:$Id: TDictionary.h 41070 2011-09-30 12:15:22Z axel $
// Author: Fons Rademakers   20/06/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TDictionary                                                          //
//                                                                      //
// This class defines an abstract interface that must be implemented    //
// by all classes that contain dictionary information.                  //
//                                                                      //
// The dictionary is defined by the followling classes:                 //
// TDataType                              (typedef definitions)         //
// TGlobal                                (global variables)            //
// TFunction                              (global functions)            //
// TClass                                 (classes)                     //
//    TBaseClass                          (base classes)                //
//    TDataMember                         (class datamembers)           //
//    TMethod                             (class methods)               //
//       TMethodArg                       (method arguments)            //
//                                                                      //
// All the above classes implement the TDictionary abstract interface   //
// (note: the indentation shows aggregation not inheritance).           //
// The ROOT dictionary system provides a very extensive RTTI            //
// environment that facilitates a.o. object inspectors, object I/O,     //
// ROOT Trees, etc. Most of the type information is provided by the     //
// CINT C++ interpreter.                                                //
//                                                                      //
// TMethodCall                            (method call environment)     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Property.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * Header file Property.h
 ************************************************************************
 * Description:
 *  Extended Run Time Type Identification API
 ************************************************************************
 * Copyright(c) 1995~1999  Masaharu Goto 
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/




/* Normal Property() */
# 59 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Property.h"
/* ECF enhancement  ClassProperty() */
# 49 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDictionary.h" 2

typedef void CallFunc_t;
typedef void ClassInfo_t;
typedef void BaseClassInfo_t;
typedef void DataMemberInfo_t;
typedef void MethodInfo_t;
typedef void MethodArgInfo_t;
typedef void MethodArgInfo_t;
typedef void TypeInfo_t;
typedef void TypedefInfo_t;

enum EProperty {
   kIsClass = 0x00000001,
   kIsStruct = 0x00000002,
   kIsUnion = 0x00000004,
   kIsEnum = 0x00000008,
   kIsNamespace = 0x08000000,
   kIsTypedef = 0x00000010,
   kIsFundamental = 0x00000020,
   kIsAbstract = 0x00000040,
   kIsVirtual = 0x00000080,
   kIsPureVirtual = 0x00000100,
   kIsPublic = 0x00000200,
   kIsProtected = 0x00000400,
   kIsPrivate = 0x00000800,
   kIsPointer = 0x00001000,
   kIsArray = 0x00002000,
   kIsStatic = 0x00004000,
   kIsUsingVariable= 0x20000000,
   kIsDefault = 0x00008000,
   kIsReference = 0x00010000,
   kIsConstant = 0x00100000,
   kIsConstPointer = 0x00400000,
   kIsMethConst = 0x10000000
};


class TDictionary : public TNamed {

public:
   TDictionary() { }
   TDictionary(const char* name): TNamed(name, "") { }
   virtual ~TDictionary() { }

   virtual Long_t Property() const = 0;
   static TDictionary* GetDictionary(const char* name);
   static TDictionary* GetDictionary(const type_info &typeinfo);

   // Type of STL container (returned by IsSTLContainer).
   enum ESTLType {kNone=0, kVector=1, kList, kDeque, kMap, kMultimap, kSet, kMultiset};

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TDictionary::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TDictionary::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDictionary.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 100; } //ABC defining interface to dictionary
};
# 27 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDataType.h" 2



enum EDataType {
   kChar_t = 1, kUChar_t = 11, kShort_t = 2, kUShort_t = 12,
   kInt_t = 3, kUInt_t = 13, kLong_t = 4, kULong_t = 14,
   kFloat_t = 5, kDouble_t = 8, kDouble32_t = 9, kchar = 10,
   kBool_t = 18, kLong64_t = 16, kULong64_t = 17, kOther_t = -1,
   kNoType_t = 0, kFloat16_t= 19,
   kCounter = 6, kCharStar = 7, kBits = 15 /* for compatibility with TStreamerInfo */,
   kVoid_t = 20,

   kDataTypeAliasUnsigned_t = 21,
   // could add "long int" etc
   kNumDataTypes
};


class TDataType : public TDictionary {

private:
   TypedefInfo_t *fInfo; //pointer to CINT typedef info
   Int_t fSize; //size of type
   EDataType fType; //type id
   Long_t fProperty; //The property information for the (potential) underlying class
   TString fTrueName; //True name of the (potential) underlying class 
   static TDataType* fgBuiltins[kNumDataTypes]; //Array of builtins

   void CheckInfo();
   void SetType(const char *name);

protected:
   TDataType(const TDataType&);
   TDataType& operator=(const TDataType&);

public:
   TDataType(TypedefInfo_t *info = 0);
   TDataType(const char *typenam);
   virtual ~TDataType();
   Int_t Size() const;
   Int_t GetType() const { return (Int_t)fType; }
   const char *GetTypeName() const;
   const char *GetFullTypeName() const;
   const char *AsString(void *buf) const;
   Long_t Property() const;

   static const char *GetTypeName(EDataType type);
   static TDataType *GetDataType(EDataType type);
   static EDataType GetType(const type_info &typeinfo);
   static void AddBuiltins(TCollection* types);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TDataType::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TDataType::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TDataType.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 78; } //Basic data type descriptor
};
# 41 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBranch.h" 2


class TTree;
class TBasket;
class TLeaf;
class TBrowser;
class TDirectory;
class TFile;
class TClonesArray;
class TTreeCloner;

   const Int_t kDoNotProcess = (1ULL << (10)); // Active bit for branches
   const Int_t kIsClone = (1ULL << (11)); // to indicate a TBranchClones
   const Int_t kBranchObject = (1ULL << (12)); // branch is a TObject*
   const Int_t kBranchAny = (1ULL << (17)); // branch is an object*
   const Int_t kMapObject = kBranchObject | kBranchAny;

class TBranch : public TNamed , public TAttFill {

protected:
   friend class TTreeCloner;
   // TBranch status bits
   enum EStatusBits {
      kAutoDelete = (1ULL << (15)),
      kDoNotUseBufferMap = (1ULL << (22)) // If set, at least one of the entry in the branch will use the buffer's map of classname and objects.
   };

   static Int_t fgCount; //! branch counter
   Int_t fCompress; //  Compression level and algorithm
   Int_t fBasketSize; //  Initial Size of  Basket Buffer
   Int_t fEntryOffsetLen; //  Initial Length of fEntryOffset table in the basket buffers
   Int_t fWriteBasket; //  Last basket number written
   Long64_t fEntryNumber; //  Current entry number (last one filled in this branch)
   Int_t fOffset; //  Offset of this branch
   Int_t fMaxBaskets; //  Maximum number of Baskets so far
   Int_t fNBaskets; //! Number of baskets in memory
   Int_t fSplitLevel; //  Branch split level
   Int_t fNleaves; //! Number of leaves
   Int_t fReadBasket; //! Current basket number when reading
   Long64_t fReadEntry; //! Current entry number when reading
   Long64_t fFirstBasketEntry;//! First entry in the current basket.
   Long64_t fNextBasketEntry; //! Next entry that will requires us to go to the next basket
   TBasket *fCurrentBasket; //! Pointer to the current basket.
   Long64_t fEntries; //  Number of entries
   Long64_t fFirstEntry; //  Number of the first entry in this branch
   Long64_t fTotBytes; //  Total number of bytes in all leaves before compression
   Long64_t fZipBytes; //  Total number of bytes in all leaves after compression
   TObjArray fBranches; //-> List of Branches of this branch
   TObjArray fLeaves; //-> List of leaves of this branch
   TObjArray fBaskets; //-> List of baskets of this branch
   Int_t *fBasketBytes; //[fMaxBaskets] Lenght of baskets on file
   Long64_t *fBasketEntry; //[fMaxBaskets] Table of first entry in eack basket
   Long64_t *fBasketSeek; //[fMaxBaskets] Addresses of baskets on file
   TTree *fTree; //! Pointer to Tree header
   TBranch *fMother; //! Pointer to top-level parent branch in the tree.
   TBranch *fParent; //! Pointer to parent branch.
   char *fAddress; //! Address of 1st leaf (variable or object)
   TDirectory *fDirectory; //! Pointer to directory where this branch buffers are stored
   TString fFileName; //  Name of file where buffers are stored ("" if in same file as Tree header)
   TBuffer *fEntryBuffer; //! Buffer used to directly pass the content without streaming
   TList *fBrowsables; //! List of TVirtualBranchBrowsables used for Browse()

   Bool_t fSkipZip; //! After being read, the buffer will not be unziped.

   typedef void (TBranch::*ReadLeaves_t)(TBuffer &b);
   ReadLeaves_t fReadLeaves; //! Pointer to the ReadLeaves implementation to use. 
   typedef void (TBranch::*FillLeaves_t)(TBuffer &b);
   FillLeaves_t fFillLeaves; //! Pointer to the FillLeaves implementation to use. 
   void ReadLeavesImpl(TBuffer &b);
   void ReadLeaves0Impl(TBuffer &b);
   void ReadLeaves1Impl(TBuffer &b);
   void ReadLeaves2Impl(TBuffer &b);
   void FillLeavesImpl(TBuffer &b);

   void SetSkipZip(Bool_t skip = kTRUE) { fSkipZip = skip; }
   void Init(const char *name, const char *leaflist, Int_t compress);

   TBasket *GetFreshBasket();
   Int_t WriteBasket(TBasket* basket, Int_t where);

   TString GetRealFileName() const;

private:
   Int_t FillEntryBuffer(TBasket* basket,TBuffer* buf, Int_t& lnew);
   TBranch(const TBranch&); // not implemented
   TBranch& operator=(const TBranch&); // not implemented

public:
   TBranch();
   TBranch(TTree *tree, const char *name, void *address, const char *leaflist, Int_t basketsize=32000, Int_t compress=-1);
   TBranch(TBranch *parent, const char *name, void *address, const char *leaflist, Int_t basketsize=32000, Int_t compress=-1);
   virtual ~TBranch();

   virtual void AddBasket(TBasket &b, Bool_t ondisk, Long64_t startEntry);
   virtual void AddLastBasket(Long64_t startEntry);
   virtual void Browse(TBrowser *b);
   virtual void DeleteBaskets(Option_t* option="");
   virtual void DropBaskets(Option_t *option = "");
           void ExpandBasketArrays();
   virtual Int_t Fill();
   virtual TBranch *FindBranch(const char *name);
   virtual TLeaf *FindLeaf(const char *name);
           Int_t FlushBaskets();
           Int_t FlushOneBasket(UInt_t which);

   virtual char *GetAddress() const {return fAddress;}
           TBasket *GetBasket(Int_t basket);
           Int_t *GetBasketBytes() const {return fBasketBytes;}
           Long64_t *GetBasketEntry() const {return fBasketEntry;}
   virtual Long64_t GetBasketSeek(Int_t basket) const;
   virtual Int_t GetBasketSize() const {return fBasketSize;}
   virtual TList *GetBrowsables();
   virtual const char* GetClassName() const;
           Int_t GetCompressionAlgorithm() const;
           Int_t GetCompressionLevel() const;
           Int_t GetCompressionSettings() const;
   TDirectory *GetDirectory() const {return fDirectory;}
   virtual Int_t GetEntry(Long64_t entry=0, Int_t getall = 0);
   virtual Int_t GetEntryExport(Long64_t entry, Int_t getall, TClonesArray *list, Int_t n);
           Int_t GetEntryOffsetLen() const { return fEntryOffsetLen; }
           Int_t GetEvent(Long64_t entry=0) {return GetEntry(entry);}
   const char *GetIconName() const;
   virtual Int_t GetExpectedType(TClass *&clptr,EDataType &type);
   virtual TLeaf *GetLeaf(const char *name) const;
   virtual TFile *GetFile(Int_t mode=0);
   const char *GetFileName() const {return fFileName.Data();}
           Int_t GetOffset() const {return fOffset;}
           Int_t GetReadBasket() const {return fReadBasket;}
           Long64_t GetReadEntry() const {return fReadEntry;}
           Int_t GetWriteBasket() const {return fWriteBasket;}
           Long64_t GetTotalSize(Option_t *option="") const;
           Long64_t GetTotBytes(Option_t *option="") const;
           Long64_t GetZipBytes(Option_t *option="") const;
           Long64_t GetEntryNumber() const {return fEntryNumber;}
           Long64_t GetFirstEntry() const {return fFirstEntry; }
         TObjArray *GetListOfBaskets() {return &fBaskets;}
         TObjArray *GetListOfBranches() {return &fBranches;}
         TObjArray *GetListOfLeaves() {return &fLeaves;}
           Int_t GetMaxBaskets() const {return fMaxBaskets;}
           Int_t GetNleaves() const {return fNleaves;}
           Int_t GetSplitLevel() const {return fSplitLevel;}
           Long64_t GetEntries() const {return fEntries;}
           TTree *GetTree() const {return fTree;}
   virtual Int_t GetRow(Int_t row);
   virtual Bool_t GetMakeClass() const;
   TBranch *GetMother() const;
   TBranch *GetSubBranch(const TBranch *br) const;
   Bool_t IsAutoDelete() const;
   Bool_t IsFolder() const;
   virtual void KeepCircular(Long64_t maxEntries);
   virtual Int_t LoadBaskets();
   virtual void Print(Option_t *option="") const;
   virtual void ReadBasket(TBuffer &b);
   virtual void Refresh(TBranch *b);
   virtual void Reset(Option_t *option="");
   virtual void ResetAfterMerge(TFileMergeInfo *);
   virtual void ResetAddress();
   virtual void ResetReadEntry() {fReadEntry = -1;}
   virtual void SetAddress(void *add);
   virtual void SetObject(void *objadd);
   virtual void SetAutoDelete(Bool_t autodel=kTRUE);
   virtual void SetBasketSize(Int_t buffsize);
   virtual void SetBufferAddress(TBuffer *entryBuffer);
   void SetCompressionAlgorithm(Int_t algorithm=0);
   void SetCompressionLevel(Int_t level=1);
   void SetCompressionSettings(Int_t settings=1);
   virtual void SetEntries(Long64_t entries);
   virtual void SetEntryOffsetLen(Int_t len, Bool_t updateSubBranches = kFALSE);
   virtual void SetFirstEntry( Long64_t entry );
   virtual void SetFile(TFile *file=0);
   virtual void SetFile(const char *filename);
   virtual Bool_t SetMakeClass(Bool_t decomposeObj = kTRUE);
   virtual void SetOffset(Int_t offset=0) {fOffset=offset;}
   virtual void SetStatus(Bool_t status=1);
   virtual void SetTree(TTree *tree) { fTree = tree;}
   virtual void SetupAddresses();
   virtual void UpdateAddress() {;}
   virtual void UpdateFile();

   static void ResetCount();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 12; } static void Dictionary(); virtual TClass *IsA() const { return TBranch::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TBranch::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBranch.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 222; }; //Branch descriptor
};

//______________________________________________________________________________
inline Int_t TBranch::GetCompressionAlgorithm() const
{
   return (fCompress < 0) ? -1 : fCompress / 100;
}

//______________________________________________________________________________
inline Int_t TBranch::GetCompressionLevel() const
{
   return (fCompress < 0) ? -1 : fCompress % 100;
}

//______________________________________________________________________________
inline Int_t TBranch::GetCompressionSettings() const
{
   return (fCompress < 0) ? -1 : fCompress;
}
# 31 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h" 2
# 62 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h"
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClass.h" 1
// @(#)root/meta:$Id: TClass.h 43993 2012-04-27 16:23:16Z pcanal $
// Author: Rene Brun   07/01/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TClass                                                               //
//                                                                      //
// Dictionary of a class.                                               //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 34 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClass.h"
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjString.h" 1
// @(#)root/base:$Id: TObjString.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Fons Rademakers   12/11/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TObjString                                                           //
//                                                                      //
// Collectable string class. This is a TObject containing a TString.    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjString.h"
class TObjString : public TObject {

private:
   TString fString; // wrapped TString

public:
   TObjString(const char *s = "") : fString(s) { }
   TObjString(const TObjString &s) : TObject(), fString(s.fString) { }
   ~TObjString() { }
   Int_t Compare(const TObject *obj) const;
   const char *GetName() const { return fString; }
   ULong_t Hash() const { return fString.Hash(); }
   void FillBuffer(char *&buffer) { fString.FillBuffer(buffer); }
   void Print(Option_t *) const { Printf("TObjString = %s", (const char*)fString); }
   Bool_t IsSortable() const { return kTRUE; }
   Bool_t IsEqual(const TObject *obj) const;
   void ReadBuffer(char *&buffer) { fString.ReadBuffer(buffer); }
   void SetString(const char *s) { fString = s; }
   TString GetString() const { return fString; }
   Int_t Sizeof() const { return fString.Sizeof(); }
   TString &String() { return fString; }

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TObjString::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TObjString::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjString.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 54; } //Collectable string class
};
# 35 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClass.h" 2

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/map" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_map" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <pair.dll>
#pragma include_noerr <map.dll>
#pragma include_noerr <map2.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/map" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/map

#pragma ifndef PREC_STL_MAP
#pragma define PREC_STL_MAP
#pragma link off global PREC_STL_MAP;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from ANSI/ISO C++ 1997/Nov draft 
// Got some ideas from Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_utility" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <utility.dll>


#pragma include_noerr <pair.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/utility" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/utility

#pragma ifndef PREC_STL_UTILITY
#pragma define PREC_STL_UTILITY
#pragma link off global PREC_STL_UTILITY;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

template <class T1, class T2>
struct pair {
  T1 first;
  T2 second;
  pair() : first(T1()), second(T2()) {}
  pair(const T1& a, const T2& b) : first(a), second(b) {}
 private:
  pair& operator=(const pair& x){first=x.first;second=x.second;return *this;}
};

#pragma endif
# 17 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_utility" 2
# 27 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/map" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_memory" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <memory.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/memory

#pragma ifndef PREC_STL_MEMORY
#pragma define PREC_STL_MEMORY
#pragma link off global PREC_STL_MEMORY;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

// Implemented by Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab
# 27 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
//////////////////////////////////////////////////////////////////////


template <class _Tp>
class allocator {
  //typedef alloc _Alloc;          // The underlying allocator.
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef typename _Tp* pointer;
  typedef const typename _Tp * const_pointer;




  typedef _Tp& reference;
  typedef const _Tp& const_reference;
  typedef _Tp value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };

  allocator() ;
  allocator(const allocator&) ;
  //template <class _Tp1> allocator(const allocator<_Tp1>&) ;
  ~allocator() ;

  pointer address(reference __x) const ;
  const_pointer address(const_reference __x) const ;

  // __n is permitted to be 0.  The C++ standard says nothing about what
  // the return value is when __n == 0.
  _Tp* allocate(size_type __n, const void* = 0) ;

  // __p is not permitted to be a null pointer.
  void deallocate(pointer __p, size_type __n);

  size_type max_size() const ;

  void construct(pointer __p, const _Tp& __val) ;
  void destroy(pointer __p) ;
};

template<>
class allocator<void> {
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef void* pointer;
  typedef const void* const_pointer;
  typedef void value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };
};
//////////////////////////////////////////////////////////////////////
# 205 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
//////////////////////////////////////////////////////////////////////

/**********************************************************************
* auto_ptr
**********************************************************************/
template <class X> class auto_ptr {
private:
  X* ptr;
  //template<class Y> struct auto_ptr_ref { };
public:
  typedef X element_type;
  explicit auto_ptr(X* p = 0) : ptr(p) {}
  auto_ptr(auto_ptr& a) {ptr=a.ptr;}

  // this implementation may not be correct
  template <class T> auto_ptr(auto_ptr<T>& a) {ptr=a.release();}
# 229 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
  auto_ptr& operator=(auto_ptr& a) {
    if (a.ptr != ptr) {
      delete ptr;
      ptr = a.ptr;
    }
    return(*this);
  }

  // this implementation may not be correct
  template <class T> auto_ptr& operator=(auto_ptr<T>& a) {
    if (a.ptr != ptr) {
       delete ptr;
       ptr = a.release();
    }
    return(*this);
  }

  ~auto_ptr() { delete ptr; }

  X& operator*() const { return *ptr; }
  X* operator->() const { return ptr; }
  X* get() const { return ptr; }
  X* release() { X *old = ptr; ptr = 0; return 0; }
# 262 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
  // auto_ptr conversions
  //auto_ptr(auto_ptr_ref<X>& x) { }
  //template<class Y> operator auto_ptr_ref<Y>() { return auto_ptr_ref<Y>(); }
  //template<class Y> operator auto_ptr<Y>() { return auto_ptr<T>(); }
};

#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_memory" 2
# 28 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/map" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <iterator.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/iterator

#pragma ifndef PREC_STL_ITERATOR
#pragma define PREC_STL_ITERATOR
#pragma link off global PREC_STL_ITERATOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from STL HP implementation 1994
// Imported from STL SGI implementation 1997 
// Imported from ANSI/ISO C++ draft Nov 1997
// Modified by Masaharu Goto
// May need improvement for the latest standard


////////////////////////////////////////////////////////////////////////
// iterator_tag
////////////////////////////////////////////////////////////////////////
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag {};
struct bidirectional_iterator_tag {};
struct random_access_iterator_tag {};

////////////////////////////////////////////////////////////////////////
// iterator template
////////////////////////////////////////////////////////////////////////
template <class T, class Distance> struct input_iterator {};
struct output_iterator {};
template <class T, class Distance> struct forward_iterator {};
template <class T, class Distance> struct bidirectional_iterator {};
template <class T, class Distance> struct random_access_iterator {};

#pragma link off class output_iterator;







////////////////////////////////////////////////////////////////////////
// iterator_category overloaded function
////////////////////////////////////////////////////////////////////////
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const input_iterator<T, Distance>&) {
    return input_iterator_tag();
}

inline output_iterator_tag iterator_category(const output_iterator&) {
    return output_iterator_tag();
}

#pragma link off function iterator_category(const output_iterator&);


template <class T, class Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<T, Distance>&) {
    return forward_iterator_tag();
}

template <class T, class Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<T, Distance>&) {
    return bidirectional_iterator_tag();
}

template <class T, class Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<T, Distance>&) {
    return random_access_iterator_tag();
}

template <class T>
inline random_access_iterator_tag
iterator_category(const T*) {
    return random_access_iterator_tag();
}


// iterator_traits, iterator and reverse_iterator template may not be
// needed for precompiled library interface 

////////////////////////////////////////////////////////////////////////
// iterator_traits
////////////////////////////////////////////////////////////////////////

template <class Iterator>
struct iterator_traits {
  typedef typename Iterator::iterator_category iterator_category;
  typedef typename Iterator::value_type value_type;
  typedef typename Iterator::difference_type difference_type;
  typedef typename Iterator::pointer pointer;
  typedef typename Iterator::reference reference;
};

// template partial specialization, implement in cint5.15.14 1587
template <class T>
struct iterator_traits<T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef T& reference;
};

// incomplete implementation in cint5.15.14 1587, need some fix
// iterator_traits<const int*> is changed as iterator_traits<const int* const>
// or something, but cint5.15.14 can not handle this well
template <class T>
struct iterator_traits<const T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef const T* pointer;
  typedef const T& reference;
};

////////////////////////////////////////////////////////////////////////
// iterator
////////////////////////////////////////////////////////////////////////
template<class Category, class T, class Distance = ptrdiff_t,
         class Pointer = T*, class Reference = T&>
struct iterator {
  typedef T value_type;
  typedef Distance difference_type;
  typedef Pointer pointer;
  typedef Reference reference;
  typedef Category iterator_category;
};


////////////////////////////////////////////////////////////////////////
// reverse_iterator
////////////////////////////////////////////////////////////////////////






template <class Iterator>
class reverse_iterator
# 166 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
{




 public:
# 181 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
   typedef Iterator::pointer pointer;
   typedef Iterator::reference reference;
   typedef ptrdiff_t difference_type;


   reverse_iterator();
   //reverse_iterator(Iterator x);



   Iterator base() const; // explicit
   reference operator*() const;
   pointer operator->() const;
   reverse_iterator& operator++();
   reverse_iterator operator++(int);
   reverse_iterator& operator--();
   reverse_iterator operator--(int);
   reverse_iterator operator+ (difference_type n) const;
   reverse_iterator& operator+=(difference_type n);
   reverse_iterator operator- (difference_type n) const;
   reverse_iterator& operator-=(difference_type n);
   reference operator[](difference_type n) const;
};
# 932 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
// for g++ 3.1,3.2
namespace __gnu_cxx
{
  // This iterator adapter is 'normal' in the sense that it does not
  // change the semantics of any of the operators of its iterator
  // parameter.  Its primary purpose is to convert an iterator that is
  // not a class, e.g. a pointer, into an iterator that is a class.
  // The _Container parameter exists solely so that different containers
  // using this template can instantiate different types, even if the
  // _Iterator parameter is the same.
  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
      : public iterator<typename iterator_traits<_Iterator>::iterator_category,
                        typename iterator_traits<_Iterator>::value_type,
                        typename iterator_traits<_Iterator>::difference_type,
                        typename iterator_traits<_Iterator>::pointer,
                        typename iterator_traits<_Iterator>::reference>
    {
    protected:
      _Iterator _M_current;

    public:
      typedef typename iterator_traits<_Iterator>::difference_type
                    difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

      __normal_iterator() : _M_current(_Iterator()) { }

      explicit
      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

      // Allow iterator to const_iterator conversion
      template<typename _Iter>
      inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
 : _M_current(__i.base()) { }

      // Forward iterator requirements
      reference
      operator*() const { return *_M_current; }

      pointer
      operator->() const { return _M_current; }

      __normal_iterator&
      operator++() { ++_M_current; return *this; }

      __normal_iterator
      operator++(int) { return __normal_iterator(_M_current++); }

      // Bidirectional iterator requirements
      __normal_iterator&
      operator--() { --_M_current; return *this; }

      __normal_iterator
      operator--(int) { return __normal_iterator(_M_current--); }

      // Random access iterator requirements
      reference
      operator[](const difference_type& __n) const
      { return _M_current[__n]; }

      __normal_iterator&
      operator+=(const difference_type& __n)
      { _M_current += __n; return *this; }

      __normal_iterator
      operator+(const difference_type& __n) const
      { return __normal_iterator(_M_current + __n); }

      __normal_iterator&
      operator-=(const difference_type& __n)
      { _M_current -= __n; return *this; }

      __normal_iterator
      operator-(const difference_type& __n) const
      { return __normal_iterator(_M_current - __n); }

      const _Iterator&
      base() const { return _M_current; }
    };

  // Note: In what follows, the left- and right-hand-side iterators are
  // allowed to vary in types (conceptually in cv-qualification) so that
  // comparaison between cv-qualified and non-cv-qualified iterators be
  // valid.  However, the greedy and unfriendly operators in std::rel_ops
  // will make overload resolution ambiguous (when in scope) if we don't
  // provide overloads whose operands are of the same type.  Can someone
  // remind me what generic programming is about? -- Gaby

  // Forward iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  // Random access iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  // _GLIBCPP_RESOLVE_LIB_DEFECTS
  // According to the resolution of DR179 not only the various comparison
  // operators but also operator- must accept mixed iterator/const_iterator
  // parameters.
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
     const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
} // namespace __gnu_cxx







#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 2
# 29 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/map" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_functional" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <functional.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/functional" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/functional

#pragma ifndef PREC_STL_FUNCTIONAL
#pragma define PREC_STL_FUNCTIONAL
#pragma link off global PREC_STL_FUNCTIONAL;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

// Implemented by Scott Snyder, Fermi-lab

// clause _lib.base_, base:
template <class Arg, class Result>
struct unary_function
{
  typedef Arg argument_type;
  typedef Result result_type;
};


template <class Arg1, class Arg2, class Result>
struct binary_function
{
  typedef Arg1 first_argument_type;
  typedef Arg2 second_argument_type;
  typedef Result result_type;
};


// clause _lib.arithmetic.operations_, arithmetic operations:
template <class T> struct plus : binary_function<T,T,T> {
  T operator()(const T& x, const T& y) const;
};


template <class T> struct minus : binary_function<T,T,T> {
  T operator()(const T& x, const T& y) const;
};


template <class T> struct multiplies : binary_function<T,T,T> {
  T operator()(const T& x, const T& y) const;
};


template <class T> struct divides : binary_function<T,T,T> {
  T operator()(const T& x, const T& y) const;
};

template <class T> struct modulus : binary_function<T,T,T> {
  T operator()(const T& x, const T& y) const;
};

template <class T> struct negate : unary_function<T,T> {
  T operator()(const T& x) const;
};


// clause _lib.comparisons_, comparisons:
template <class T> struct equal_to : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct not_equal_to : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct greater : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct less : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct greater_equal : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct less_equal : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};


// clause _lib.logical.operations_, logical operations:
template <class T> struct logical_and : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct logical_or : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct logical_not : unary_function<T,bool> {
  bool operator()(const T& x) const;
};


// clause _lib.negators_, negators:
template <class Predicate>
class unary_negate
  : public unary_function<Predicate::argument_type, bool>
{
public:
  explicit unary_negate(const Predicate& pred);
  bool operator()(const argument_type& x) const;
};






template <class Predicate>
class binary_negate
  : public binary_function<Predicate::first_argument_type,
                           Predicate::second_argument_type, bool>
{
public:
  explicit binary_negate(const Predicate& pred);
  bool operator()(const first_argument_type& x,
                  const second_argument_type& y) const;
};

// operations omitted (cint can't handle template forward decls...)







// clause _lib.binders_, binders:
template <class Operation>
class binder1st
  : public unary_function<Operation::second_argument_type,
                          Operation::result_type>
{
protected:
  Operation op;
  Operation::first_argument_type value;
public:
  binder1st(const Operation& x, const Operation::first_argument_type& y);
  result_type operator()(const argument_type& x) const;
};


// operations omitted (cint can't handle template forward decls...)





template <class Operation>
class binder2nd
  : public unary_function<Operation::first_argument_type,
                          Operation::result_type>
{
protected:
  Operation op;
  Operation::second_argument_type value;
public:
  binder2nd(const Operation& x, const Operation::second_argument_type& y);
  result_type operator()(const argument_type& x) const;
};


// operations omitted (cint can't handle template forward decls...)






// clause _lib.function.pointer.adaptors_, adaptors:
template <class Arg, class Result>
class pointer_to_unary_function
  : public unary_function<Arg, Result>
{
public:
  explicit pointer_to_unary_function(Result (*f)(Arg));
  Result operator()(Arg x) const;
};

// operations omitted (cint can't handle template forward decls...)





template <class Arg1, class Arg2, class Result>
class pointer_to_binary_function
  : public binary_function<Arg1,Arg2,Result>
{
public:
  explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
  Result operator()(Arg1 x, Arg2 y) const;
};

// operations omitted (cint can't handle template forward decls...)






// omit these for now.
# 230 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/functional"
#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_functional" 2
# 30 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/map" 2

//////////////////////////////////////////////////////////////////////////

template<class Key,class T,class Compare=std::less<Key>
        ,class Allocator=std::allocator<pair<const Key, T> > >
# 63 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/map"
class map {
 public:
  typedef Key key_type;
  typedef T mapped_type;



  typedef pair<Key,T> value_type;

  typedef Compare key_compare;
  typedef Allocator allocator_type;

  //typedef Key*                                     pointer;
  //typedef const Key*                               const_pointer;
  //typedef Key&                                     reference;
  //typedef const Key&                               const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
# 90 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/map"
  class iterator
# 103 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/map"
 {
   public:
    iterator() ;
    iterator(const iterator& x) ;

    iterator& operator=(const iterator& x) ;

    value_type& operator*() ;

    value_type* operator->() ;

    iterator& operator++();
    iterator operator++(int a);
    iterator& operator--();
    iterator operator--(int a);

    bool operator==(const iterator& x) ;
    bool operator!=(const iterator& x) ;




  };
# 134 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/map"
  class reverse_iterator
# 147 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/map"
 {
   public:
    reverse_iterator(const reverse_iterator& x);

    reverse_iterator& operator=(const reverse_iterator& x) ;

    value_type& operator*() ;

    value_type* operator->() ;

    reverse_iterator& operator++();
    reverse_iterator operator++(int a);
    reverse_iterator& operator--();
    reverse_iterator operator--(int a);
   private:
  };

  friend bool operator==(const map::reverse_iterator& x
                        ,const map::reverse_iterator& y) const;
  friend bool operator!=(const map::reverse_iterator& x
                        ,const map::reverse_iterator& y) const;


  typedef const iterator const_iterator;
  typedef const reverse_iterator const_reverse_iterator;

  // _lib.map.cons_ construct/copy/destroy:
  map();






  map(iterator first, iterator last);
  map(reverse_iterator first, reverse_iterator last);

  map(const map& x);
  ~map();
  map& operator=(const map& x);
  // iterators:
  iterator begin();
  iterator end();
  reverse_iterator rbegin();
  reverse_iterator rend();






  // capacity:
  bool empty() const;
  size_type size() const;
  size_type max_size() const;
  // _lib.map.access_ element access:
  T& operator[](const Key& x);
  // modifiers:
  pair<map::iterator, bool> insert(const value_type& x);
  iterator insert(iterator position, const value_type& x);





  void insert(iterator first, iterator last);
  void insert(reverse_iterator first, reverse_iterator last);

  void erase(iterator position);
  size_type erase(const Key& x);
  void erase(iterator first, iterator last);
  void swap(map&);
  void clear();
  // observers:
  //key_compare   key_comp() const;
  //value_compare value_comp() const;
  // _lib.map.ops_ map operations:
  iterator find(const Key& x);
  //const_iterator find(const Key& x) const;
  size_type count(const Key& x) const;
  iterator lower_bound(const Key& x);
  //const_iterator lower_bound(const Key& x) const;
  iterator upper_bound(const Key& x);
  //const_iterator upper_bound(const Key& x) const;





  friend bool operator==(const map& x, const map& y);
  friend bool operator< (const map& x, const map& y);
  friend bool operator!=(const map& x, const map& y);
  friend bool operator> (const map& x, const map& y);
  friend bool operator>=(const map& x, const map& y);
  friend bool operator<=(const map& x, const map& y);
  // specialized algorithms:





#pragma ifndef G__NOALGORITHM
  // Generic algorithm
  friend map::iterator
    search(map::iterator first1,map::iterator last1,
           map::iterator first2,map::iterator last2);
#pragma endif

  // iterator_category resolution
  //friend bidirectional_iterator_tag iterator_category(map::iterator x);

};

//////////////////////////////////////////////////////////////////////////

#pragma endif
# 16 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_map" 2
# 26 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_map"
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_multimap" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

//#pragma include_noerr <pair.dll> 
#pragma include_noerr <multimap.dll>
#pragma include_noerr <multimap2.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/multimap" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/multimap

#pragma ifndef PREC_STL_MULTIMAP
#pragma define PREC_STL_MULTIMAP
#pragma link off global PREC_STL_MULTIMAP;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from ANSI/ISO C++ 1997/Nov draft 
// Got some ideas from Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_utility" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <utility.dll>


#pragma include_noerr <pair.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/utility" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/utility

#pragma ifndef PREC_STL_UTILITY
#pragma define PREC_STL_UTILITY
#pragma link off global PREC_STL_UTILITY;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

template <class T1, class T2>
struct pair {
  T1 first;
  T2 second;
  pair() : first(T1()), second(T2()) {}
  pair(const T1& a, const T2& b) : first(a), second(b) {}
 private:
  pair& operator=(const pair& x){first=x.first;second=x.second;return *this;}
};

#pragma endif
# 17 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_utility" 2
# 27 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/multimap" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_memory" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <memory.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/memory

#pragma ifndef PREC_STL_MEMORY
#pragma define PREC_STL_MEMORY
#pragma link off global PREC_STL_MEMORY;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

// Implemented by Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab
# 27 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
//////////////////////////////////////////////////////////////////////


template <class _Tp>
class allocator {
  //typedef alloc _Alloc;          // The underlying allocator.
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef typename _Tp* pointer;
  typedef const typename _Tp * const_pointer;




  typedef _Tp& reference;
  typedef const _Tp& const_reference;
  typedef _Tp value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };

  allocator() ;
  allocator(const allocator&) ;
  //template <class _Tp1> allocator(const allocator<_Tp1>&) ;
  ~allocator() ;

  pointer address(reference __x) const ;
  const_pointer address(const_reference __x) const ;

  // __n is permitted to be 0.  The C++ standard says nothing about what
  // the return value is when __n == 0.
  _Tp* allocate(size_type __n, const void* = 0) ;

  // __p is not permitted to be a null pointer.
  void deallocate(pointer __p, size_type __n);

  size_type max_size() const ;

  void construct(pointer __p, const _Tp& __val) ;
  void destroy(pointer __p) ;
};

template<>
class allocator<void> {
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef void* pointer;
  typedef const void* const_pointer;
  typedef void value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };
};
//////////////////////////////////////////////////////////////////////
# 205 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
//////////////////////////////////////////////////////////////////////

/**********************************************************************
* auto_ptr
**********************************************************************/
template <class X> class auto_ptr {
private:
  X* ptr;
  //template<class Y> struct auto_ptr_ref { };
public:
  typedef X element_type;
  explicit auto_ptr(X* p = 0) : ptr(p) {}
  auto_ptr(auto_ptr& a) {ptr=a.ptr;}

  // this implementation may not be correct
  template <class T> auto_ptr(auto_ptr<T>& a) {ptr=a.release();}
# 229 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
  auto_ptr& operator=(auto_ptr& a) {
    if (a.ptr != ptr) {
      delete ptr;
      ptr = a.ptr;
    }
    return(*this);
  }

  // this implementation may not be correct
  template <class T> auto_ptr& operator=(auto_ptr<T>& a) {
    if (a.ptr != ptr) {
       delete ptr;
       ptr = a.release();
    }
    return(*this);
  }

  ~auto_ptr() { delete ptr; }

  X& operator*() const { return *ptr; }
  X* operator->() const { return ptr; }
  X* get() const { return ptr; }
  X* release() { X *old = ptr; ptr = 0; return 0; }
# 262 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
  // auto_ptr conversions
  //auto_ptr(auto_ptr_ref<X>& x) { }
  //template<class Y> operator auto_ptr_ref<Y>() { return auto_ptr_ref<Y>(); }
  //template<class Y> operator auto_ptr<Y>() { return auto_ptr<T>(); }
};

#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_memory" 2
# 28 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/multimap" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <iterator.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/iterator

#pragma ifndef PREC_STL_ITERATOR
#pragma define PREC_STL_ITERATOR
#pragma link off global PREC_STL_ITERATOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from STL HP implementation 1994
// Imported from STL SGI implementation 1997 
// Imported from ANSI/ISO C++ draft Nov 1997
// Modified by Masaharu Goto
// May need improvement for the latest standard


////////////////////////////////////////////////////////////////////////
// iterator_tag
////////////////////////////////////////////////////////////////////////
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag {};
struct bidirectional_iterator_tag {};
struct random_access_iterator_tag {};

////////////////////////////////////////////////////////////////////////
// iterator template
////////////////////////////////////////////////////////////////////////
template <class T, class Distance> struct input_iterator {};
struct output_iterator {};
template <class T, class Distance> struct forward_iterator {};
template <class T, class Distance> struct bidirectional_iterator {};
template <class T, class Distance> struct random_access_iterator {};

#pragma link off class output_iterator;







////////////////////////////////////////////////////////////////////////
// iterator_category overloaded function
////////////////////////////////////////////////////////////////////////
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const input_iterator<T, Distance>&) {
    return input_iterator_tag();
}

inline output_iterator_tag iterator_category(const output_iterator&) {
    return output_iterator_tag();
}

#pragma link off function iterator_category(const output_iterator&);


template <class T, class Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<T, Distance>&) {
    return forward_iterator_tag();
}

template <class T, class Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<T, Distance>&) {
    return bidirectional_iterator_tag();
}

template <class T, class Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<T, Distance>&) {
    return random_access_iterator_tag();
}

template <class T>
inline random_access_iterator_tag
iterator_category(const T*) {
    return random_access_iterator_tag();
}


// iterator_traits, iterator and reverse_iterator template may not be
// needed for precompiled library interface 

////////////////////////////////////////////////////////////////////////
// iterator_traits
////////////////////////////////////////////////////////////////////////

template <class Iterator>
struct iterator_traits {
  typedef typename Iterator::iterator_category iterator_category;
  typedef typename Iterator::value_type value_type;
  typedef typename Iterator::difference_type difference_type;
  typedef typename Iterator::pointer pointer;
  typedef typename Iterator::reference reference;
};

// template partial specialization, implement in cint5.15.14 1587
template <class T>
struct iterator_traits<T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef T& reference;
};

// incomplete implementation in cint5.15.14 1587, need some fix
// iterator_traits<const int*> is changed as iterator_traits<const int* const>
// or something, but cint5.15.14 can not handle this well
template <class T>
struct iterator_traits<const T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef const T* pointer;
  typedef const T& reference;
};

////////////////////////////////////////////////////////////////////////
// iterator
////////////////////////////////////////////////////////////////////////
template<class Category, class T, class Distance = ptrdiff_t,
         class Pointer = T*, class Reference = T&>
struct iterator {
  typedef T value_type;
  typedef Distance difference_type;
  typedef Pointer pointer;
  typedef Reference reference;
  typedef Category iterator_category;
};


////////////////////////////////////////////////////////////////////////
// reverse_iterator
////////////////////////////////////////////////////////////////////////






template <class Iterator>
class reverse_iterator
# 166 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
{




 public:
# 181 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
   typedef Iterator::pointer pointer;
   typedef Iterator::reference reference;
   typedef ptrdiff_t difference_type;


   reverse_iterator();
   //reverse_iterator(Iterator x);



   Iterator base() const; // explicit
   reference operator*() const;
   pointer operator->() const;
   reverse_iterator& operator++();
   reverse_iterator operator++(int);
   reverse_iterator& operator--();
   reverse_iterator operator--(int);
   reverse_iterator operator+ (difference_type n) const;
   reverse_iterator& operator+=(difference_type n);
   reverse_iterator operator- (difference_type n) const;
   reverse_iterator& operator-=(difference_type n);
   reference operator[](difference_type n) const;
};
# 932 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
// for g++ 3.1,3.2
namespace __gnu_cxx
{
  // This iterator adapter is 'normal' in the sense that it does not
  // change the semantics of any of the operators of its iterator
  // parameter.  Its primary purpose is to convert an iterator that is
  // not a class, e.g. a pointer, into an iterator that is a class.
  // The _Container parameter exists solely so that different containers
  // using this template can instantiate different types, even if the
  // _Iterator parameter is the same.
  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
      : public iterator<typename iterator_traits<_Iterator>::iterator_category,
                        typename iterator_traits<_Iterator>::value_type,
                        typename iterator_traits<_Iterator>::difference_type,
                        typename iterator_traits<_Iterator>::pointer,
                        typename iterator_traits<_Iterator>::reference>
    {
    protected:
      _Iterator _M_current;

    public:
      typedef typename iterator_traits<_Iterator>::difference_type
                    difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

      __normal_iterator() : _M_current(_Iterator()) { }

      explicit
      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

      // Allow iterator to const_iterator conversion
      template<typename _Iter>
      inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
 : _M_current(__i.base()) { }

      // Forward iterator requirements
      reference
      operator*() const { return *_M_current; }

      pointer
      operator->() const { return _M_current; }

      __normal_iterator&
      operator++() { ++_M_current; return *this; }

      __normal_iterator
      operator++(int) { return __normal_iterator(_M_current++); }

      // Bidirectional iterator requirements
      __normal_iterator&
      operator--() { --_M_current; return *this; }

      __normal_iterator
      operator--(int) { return __normal_iterator(_M_current--); }

      // Random access iterator requirements
      reference
      operator[](const difference_type& __n) const
      { return _M_current[__n]; }

      __normal_iterator&
      operator+=(const difference_type& __n)
      { _M_current += __n; return *this; }

      __normal_iterator
      operator+(const difference_type& __n) const
      { return __normal_iterator(_M_current + __n); }

      __normal_iterator&
      operator-=(const difference_type& __n)
      { _M_current -= __n; return *this; }

      __normal_iterator
      operator-(const difference_type& __n) const
      { return __normal_iterator(_M_current - __n); }

      const _Iterator&
      base() const { return _M_current; }
    };

  // Note: In what follows, the left- and right-hand-side iterators are
  // allowed to vary in types (conceptually in cv-qualification) so that
  // comparaison between cv-qualified and non-cv-qualified iterators be
  // valid.  However, the greedy and unfriendly operators in std::rel_ops
  // will make overload resolution ambiguous (when in scope) if we don't
  // provide overloads whose operands are of the same type.  Can someone
  // remind me what generic programming is about? -- Gaby

  // Forward iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  // Random access iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  // _GLIBCPP_RESOLVE_LIB_DEFECTS
  // According to the resolution of DR179 not only the various comparison
  // operators but also operator- must accept mixed iterator/const_iterator
  // parameters.
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
     const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
} // namespace __gnu_cxx







#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 2
# 29 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/multimap" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_functional" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <functional.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/functional" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/functional

#pragma ifndef PREC_STL_FUNCTIONAL
#pragma define PREC_STL_FUNCTIONAL
#pragma link off global PREC_STL_FUNCTIONAL;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

// Implemented by Scott Snyder, Fermi-lab

// clause _lib.base_, base:
template <class Arg, class Result>
struct unary_function
{
  typedef Arg argument_type;
  typedef Result result_type;
};


template <class Arg1, class Arg2, class Result>
struct binary_function
{
  typedef Arg1 first_argument_type;
  typedef Arg2 second_argument_type;
  typedef Result result_type;
};


// clause _lib.arithmetic.operations_, arithmetic operations:
template <class T> struct plus : binary_function<T,T,T> {
  T operator()(const T& x, const T& y) const;
};


template <class T> struct minus : binary_function<T,T,T> {
  T operator()(const T& x, const T& y) const;
};


template <class T> struct multiplies : binary_function<T,T,T> {
  T operator()(const T& x, const T& y) const;
};


template <class T> struct divides : binary_function<T,T,T> {
  T operator()(const T& x, const T& y) const;
};

template <class T> struct modulus : binary_function<T,T,T> {
  T operator()(const T& x, const T& y) const;
};

template <class T> struct negate : unary_function<T,T> {
  T operator()(const T& x) const;
};


// clause _lib.comparisons_, comparisons:
template <class T> struct equal_to : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct not_equal_to : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct greater : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct less : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct greater_equal : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct less_equal : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};


// clause _lib.logical.operations_, logical operations:
template <class T> struct logical_and : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct logical_or : binary_function<T,T,bool> {
  bool operator()(const T& x, const T& y) const;
};

template <class T> struct logical_not : unary_function<T,bool> {
  bool operator()(const T& x) const;
};


// clause _lib.negators_, negators:
template <class Predicate>
class unary_negate
  : public unary_function<Predicate::argument_type, bool>
{
public:
  explicit unary_negate(const Predicate& pred);
  bool operator()(const argument_type& x) const;
};






template <class Predicate>
class binary_negate
  : public binary_function<Predicate::first_argument_type,
                           Predicate::second_argument_type, bool>
{
public:
  explicit binary_negate(const Predicate& pred);
  bool operator()(const first_argument_type& x,
                  const second_argument_type& y) const;
};

// operations omitted (cint can't handle template forward decls...)







// clause _lib.binders_, binders:
template <class Operation>
class binder1st
  : public unary_function<Operation::second_argument_type,
                          Operation::result_type>
{
protected:
  Operation op;
  Operation::first_argument_type value;
public:
  binder1st(const Operation& x, const Operation::first_argument_type& y);
  result_type operator()(const argument_type& x) const;
};


// operations omitted (cint can't handle template forward decls...)





template <class Operation>
class binder2nd
  : public unary_function<Operation::first_argument_type,
                          Operation::result_type>
{
protected:
  Operation op;
  Operation::second_argument_type value;
public:
  binder2nd(const Operation& x, const Operation::second_argument_type& y);
  result_type operator()(const argument_type& x) const;
};


// operations omitted (cint can't handle template forward decls...)






// clause _lib.function.pointer.adaptors_, adaptors:
template <class Arg, class Result>
class pointer_to_unary_function
  : public unary_function<Arg, Result>
{
public:
  explicit pointer_to_unary_function(Result (*f)(Arg));
  Result operator()(Arg x) const;
};

// operations omitted (cint can't handle template forward decls...)





template <class Arg1, class Arg2, class Result>
class pointer_to_binary_function
  : public binary_function<Arg1,Arg2,Result>
{
public:
  explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
  Result operator()(Arg1 x, Arg2 y) const;
};

// operations omitted (cint can't handle template forward decls...)






// omit these for now.
# 230 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/functional"
#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_functional" 2
# 30 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/multimap" 2

//////////////////////////////////////////////////////////////////////////

// This does not work yet. Don't know why.
template<class Key,class T,class Compare=std::less<Key>
        ,class Allocator=std::allocator<pair<const Key,T> > >
# 63 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/multimap"
class multimap {
 public:
  typedef Key key_type;
  typedef T mapped_type;
  typedef pair<Key,T> value_type;
  //typedef pair<const Key,T>                         value_type;
  typedef Compare key_compare;
  typedef Allocator allocator_type;

  //typedef Key*                                     pointer;
  //typedef const Key*                               const_pointer;
  //typedef Key&                                     reference;
  //typedef const Key&                               const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
# 87 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/multimap"
  class iterator
# 100 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/multimap"
 {
   public:
    iterator() ;
    iterator(const iterator& x) ;

    iterator& operator=(const iterator& x) ;

    value_type& operator*() ;

    value_type* operator->() ;

    iterator& operator++();
    iterator operator++(int a);
    iterator& operator--();
    iterator operator--(int a);

    bool operator==(const iterator& x) ;
    bool operator!=(const iterator& x) ;




  };
# 131 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/multimap"
  class reverse_iterator
# 144 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/multimap"
 {
   public:
    reverse_iterator(const reverse_iterator& x);

    reverse_iterator& operator=(const reverse_iterator& x) ;

    value_type& operator*() ;

    value_type* operator->() ;

    reverse_iterator& operator++();
    reverse_iterator operator++(int a);
    reverse_iterator& operator--();
    reverse_iterator operator--(int a);
   private:
  };

  friend bool operator==(const multimap::reverse_iterator& x
                        ,const multimap::reverse_iterator& y) const;
  friend bool operator!=(const multimap::reverse_iterator& x
                        ,const multimap::reverse_iterator& y) const;


  typedef const iterator const_iterator;
  typedef const reverse_iterator const_reverse_iterator;

  // _lib.multimap.cons_ construct/copy/destroy:
  multimap();






  multimap(iterator first, iterator last);
  multimap(reverse_iterator first, reverse_iterator last);

  multimap(const multimap& x);
  ~multimap();
  multimap& operator=(const multimap& x);
  // iterators:
  iterator begin();
  iterator end();
  reverse_iterator rbegin();
  reverse_iterator rend();






  // capacity:
  bool empty() const;
  size_type size() const;
  size_type max_size() const;
  // _lib.multimap.access_ element access:
  //T& operator[](const Key& x);
  // modifiers:
  iterator insert(const value_type& x);
  iterator insert(iterator position, const value_type& x);





  void insert(iterator first, iterator last);
  void insert(reverse_iterator first, reverse_iterator last);

  void erase(iterator position);
  size_type erase(const Key& x);
  void erase(iterator first, iterator last);
  void swap(multimap&);
  void clear();
  // observers:
  //key_compare   key_comp() const;
  //value_compare value_comp() const;
  // _lib.multimap.ops_ multimap operations:
  iterator find(const Key& x);
  //const_iterator find(const Key& x) const;
  size_type count(const Key& x) const;
  iterator lower_bound(const Key& x);
  //const_iterator lower_bound(const Key& x) const;
  iterator upper_bound(const Key& x);
  //const_iterator upper_bound(const Key& x) const;





  friend bool operator==(const multimap& x, const multimap& y);
  friend bool operator< (const multimap& x, const multimap& y);
  friend bool operator!=(const multimap& x, const multimap& y);
  friend bool operator> (const multimap& x, const multimap& y);
  friend bool operator>=(const multimap& x, const multimap& y);
  friend bool operator<=(const multimap& x, const multimap& y);
  // specialized algorithms:





#pragma ifndef G__NOALGORITHM
  // Generic algorithm
  friend multimap::iterator
    search(multimap::iterator first1,multimap::iterator last1,
           multimap::iterator first2,multimap::iterator last2);
#pragma endif


  // Generic algorithm
  //friend void reverse(multimap::iterator first,multimap::iterator last);
  //friend void reverse(multimap::reverse_iterator first,multimap::reverse_itetator last);

  // iterator_category resolution
  //friend bidirectional_iterator_tag iterator_category(multimap::iterator x);

};

//////////////////////////////////////////////////////////////////////////

#pragma endif
# 16 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_multimap" 2
# 26 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_map" 2
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/map" 2
}
# 37 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClass.h" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/string" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_string" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// string
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/string" 2
}
# 38 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClass.h" 2

class TBaseClass;
class TBrowser;
class TDataMember;
class TClassRef;
class TMethod;
class TRealData;
class TCint;
class TBuffer;
class TVirtualStreamerInfo;
class TVirtualCollectionProxy;
class TMethodCall;
class TVirtualIsAProxy;
class TVirtualRefProxy;
class THashTable;

namespace clang {
   class Decl;
}

namespace ROOT {
   class TGenericClassInfo;
   class TCollectionProxyInfo;
   class TSchemaRuleSet;
}

namespace ROOT {
   class TMapTypeToTClass;
}
typedef ROOT::TMapTypeToTClass IdMap_t;

class TClass : public TDictionary {

friend class TCint;
friend class TCintWithCling;
friend void ROOT::ResetClassVersion(TClass*, const char*, Short_t);
friend class ROOT::TGenericClassInfo;

public:
   // TClass status bits
   enum { kClassSaved = (1ULL << (12)), kIgnoreTObjectStreamer = (1ULL << (15)),
          kUnloaded = (1ULL << (16)), kIsTObject = (1ULL << (17)),
          kIsForeign = (1ULL << (18)), kIsEmulation = (1ULL << (19)),
          kStartWithTObject = (1ULL << (20)), // see comments for IsStartingWithTObject()
          kWarned = (1ULL << (21)),
          kHasNameMapNode = (1ULL << (22))
   };
   enum ENewType { kRealNew = 0, kClassNew, kDummyNew };

private:

   mutable TObjArray *fStreamerInfo; //Array of TVirtualStreamerInfo
   mutable std::map<std::string, TObjArray*> *fConversionStreamerInfo; //Array of the streamer infos derived from another class.
   TList *fRealData; //linked list for persistent members including base classes
   TList *fBase; //linked list for base classes
   TList *fData; //linked list for data members
   TList *fMethod; //linked list for methods
   TList *fAllPubData; //all public data members (including from base classes)
   TList *fAllPubMethod; //all public methods (including from base classes)
   mutable TList *fClassMenuList; //list of class menu items

   const char *fDeclFileName; //name of class declaration file
   const char *fImplFileName; //name of class implementation file
   Short_t fDeclFileLine; //line of class declaration
   Short_t fImplFileLine; //line of class implementation
   UInt_t fInstanceCount; //number of instances of this class
   UInt_t fOnHeap; //number of instances on heap
   mutable UInt_t fCheckSum; //checksum of data members and base classes
   TVirtualCollectionProxy *fCollectionProxy; //Collection interface
   Version_t fClassVersion; //Class version Identifier
   ClassInfo_t *fClassInfo; //pointer to CINT class info class
   TString fContextMenuTitle;//context menu title
   const type_info *fTypeInfo; //pointer to the C++ type information.
   ShowMembersFunc_t fShowMembers; //pointer to the class's ShowMembers function
   mutable void *fInterShowMembers;//Interpreter call setup for ShowMembers
   TClassStreamer *fStreamer; //pointer to streamer function
   TString fSharedLibs; //shared libraries containing class code

   TVirtualIsAProxy *fIsA; //!pointer to the class's IsA proxy.
   IsAGlobalFunc_t fGlobalIsA; //pointer to a global IsA function.
   mutable TMethodCall *fIsAMethod; //!saved info to call a IsA member function

   ROOT::MergeFunc_t fMerge; //pointer to a function implementing Merging objects of this class.
   ROOT::ResetAfterMergeFunc_t fResetAfterMerge; //pointer to a function implementing Merging objects of this class.
   ROOT::NewFunc_t fNew; //pointer to a function newing one object.
   ROOT::NewArrFunc_t fNewArray; //pointer to a function newing an array of objects.
   ROOT::DelFunc_t fDelete; //pointer to a function deleting one object.
   ROOT::DelArrFunc_t fDeleteArray; //pointer to a function deleting an array of objects.
   ROOT::DesFunc_t fDestructor; //pointer to a function call an object's destructor.
   ROOT::DirAutoAdd_t fDirAutoAdd; //pointer which implements the Directory Auto Add feature for this class.']'
   ClassStreamerFunc_t fStreamerFunc; //Wrapper around this class custom Streamer member function.
   Int_t fSizeof; //Sizeof the class.

   mutable Int_t fCanSplit; //!Indicates whether this class can be split or not.
   mutable Long_t fProperty; //!Property
   mutable Bool_t fVersionUsed; //!Indicates whether GetClassVersion has been called

   mutable Bool_t fIsOffsetStreamerSet; //!saved remember if fOffsetStreamer has been set.
   mutable Long_t fOffsetStreamer; //!saved info to call Streamer
   Int_t fStreamerType; //!cached of the streaming method to use
   mutable TVirtualStreamerInfo *fCurrentInfo; //!cached current streamer info.
   TClassRef *fRefStart; //!List of references to this object
   TVirtualRefProxy *fRefProxy; //!Pointer to reference proxy if this class represents a reference
   ROOT::TSchemaRuleSet *fSchemaRules; //! Schema evolution rules

   typedef void (TClass::*StreamerImpl_t)(void *obj, TBuffer &b, const TClass *onfile_class) const;
   mutable StreamerImpl_t fStreamerImpl;//! Pointer to the function implementing the right streaming behavior for the class represented by this object.

   TMethod *GetClassMethod(Long_t faddr);
   TMethod *GetClassMethod(const char *name, const char *signature);
   Int_t GetBaseClassOffsetRecurse(const TClass *base);
   void Init(const char *name, Version_t cversion, const type_info *info,
             TVirtualIsAProxy *isa, ShowMembersFunc_t showmember,
             const char *dfil, const char *ifil,
             Int_t dl, Int_t il,
             Bool_t silent);
   void ForceReload (TClass* oldcl);

   void SetClassVersion(Version_t version);
   void SetClassSize(Int_t sizof) { fSizeof = sizof; }

   // Various implementation for TClass::Stramer
   void StreamerExternal(void *object, TBuffer &b, const TClass *onfile_class) const;
   void StreamerTObject(void *object, TBuffer &b, const TClass *onfile_class) const;
   void StreamerTObjectInitialized(void *object, TBuffer &b, const TClass *onfile_class) const;
   void StreamerTObjectEmulated(void *object, TBuffer &b, const TClass *onfile_class) const;
   void StreamerInstrumented(void *object, TBuffer &b, const TClass *onfile_class) const;
   void StreamerStreamerInfo(void *object, TBuffer &b, const TClass *onfile_class) const;
   void StreamerDefault(void *object, TBuffer &b, const TClass *onfile_class) const;

   static IdMap_t *GetIdMap(); //Map from typeid to TClass pointer
   static ENewType fgCallingNew; //Intent of why/how TClass::New() is called
   static Int_t fgClassCount; //provides unique id for a each class
                                        //stored in TObject::fUniqueID
   // Internal status bits
   enum { kLoading = (1ULL << (14)) };
   // Internal streamer type.
   enum EStreamerType {kDefault=0, kEmulated=1, kTObject=2, kInstrumented=4, kForeign=8, kExternal=16};

   // When a new class is created, we need to be able to find
   // if there are any existing classes that have the same name
   // after any typedefs are expanded.  (This only really affects
   // template arguments.)  To avoid having to search through all classes
   // in that case, we keep a hash table mapping from the fully
   // typedef-expanded names to the original class names.
   // An entry is made in the table only if they are actually different.
   //
   // In these objects, the TObjString base holds the typedef-expanded
   // name (the hash key), and fOrigName holds the original class name
   // (the value to which the key maps).
   //
   class TNameMapNode
     : public TObjString
   {
   public:
     TNameMapNode (const char* typedf, const char* orig);
     TString fOrigName;
   };

   // These are the above-referenced hash tables.  (The pointers are null
   // if no entries have been made.)  There are actually two variants.
   // In the first, the typedef names are resolved with
   // TClassEdit::ResolveTypedef; in the second, the class names
   // are first massaged with TClassEdit::ShortType with kDropStlDefault.
   // (??? Are the two distinct tables really needed?)
   static THashTable* fgClassTypedefHash;
   static THashTable* fgClassShortTypedefHash;

private:
   TClass(const TClass& tc);
   TClass& operator=(const TClass&);

protected:
   TVirtualStreamerInfo *FindStreamerInfo(TObjArray* arr, UInt_t checksum) const;
   static THashTable *GetClassShortTypedefHash();

public:
   TClass();
   TClass(const char *name, Bool_t silent = kFALSE);
   TClass(const char *name, Version_t cversion,
          const char *dfil = 0, const char *ifil = 0,
          Int_t dl = 0, Int_t il = 0, Bool_t silent = kFALSE);
   TClass(const char *name, Version_t cversion,
          const type_info &info, TVirtualIsAProxy *isa,
          ShowMembersFunc_t showmember,
          const char *dfil, const char *ifil,
          Int_t dl, Int_t il, Bool_t silent = kFALSE);
   virtual ~TClass();

   void AddInstance(Bool_t heap = kFALSE) { fInstanceCount++; if (heap) fOnHeap++; }
   void AddImplFile(const char *filename, int line);
   void AddRef(TClassRef *ref);
   static Bool_t AddRule(const char *rule);
   static Int_t ReadRules(const char *filename);
   static Int_t ReadRules();
   void AdoptSchemaRules( ROOT::TSchemaRuleSet *rules );
   virtual void Browse(TBrowser *b);
   void BuildRealData(void *pointer=0, Bool_t isTransient = kFALSE);
   void BuildEmulatedRealData(const char *name, Long_t offset, TClass *cl);
   void CalculateStreamerOffset() const;
   Bool_t CallShowMembers(void* obj, TMemberInspector &insp,
                                      Int_t isATObject = -1) const;
   Bool_t CanSplit() const;
   Bool_t CanIgnoreTObjectStreamer() { return TestBit(kIgnoreTObjectStreamer);}
   TObject *Clone(const char *newname="") const;
   void CopyCollectionProxy(const TVirtualCollectionProxy&);
   void Draw(Option_t *option="");
   void Dump() const { TDictionary::Dump(); }
   void Dump(void *obj) const;
   char *EscapeChars(const char *text) const;
   TVirtualStreamerInfo *FindStreamerInfo(UInt_t checksum) const;
   TVirtualStreamerInfo *GetConversionStreamerInfo( const char* onfile_classname, Int_t version ) const;
   TVirtualStreamerInfo *FindConversionStreamerInfo( const char* onfile_classname, UInt_t checksum ) const;
   TVirtualStreamerInfo *GetConversionStreamerInfo( const TClass* onfile_cl, Int_t version ) const;
   TVirtualStreamerInfo *FindConversionStreamerInfo( const TClass* onfile_cl, UInt_t checksum ) const;
   Bool_t HasDefaultConstructor() const;
   UInt_t GetCheckSum(UInt_t code=0) const;
   TVirtualCollectionProxy *GetCollectionProxy() const;
   TVirtualIsAProxy *GetIsAProxy() const;
   Version_t GetClassVersion() const { fVersionUsed = kTRUE; return fClassVersion; }
   TDataMember *GetDataMember(const char *datamember) const;
   Long_t GetDataMemberOffset(const char *membername) const;
   const char *GetDeclFileName() const { return fDeclFileName; }
   Short_t GetDeclFileLine() const { return fDeclFileLine; }
   ROOT::DelFunc_t GetDelete() const;
   ROOT::DesFunc_t GetDestructor() const;
   ROOT::DelArrFunc_t GetDeleteArray() const;
   ClassInfo_t *GetClassInfo() const { return fClassInfo; }
   const char *GetContextMenuTitle() const { return fContextMenuTitle; }
   TVirtualStreamerInfo *GetCurrentStreamerInfo() {
      if (fCurrentInfo) return fCurrentInfo;
      else return (fCurrentInfo=(TVirtualStreamerInfo*)(fStreamerInfo->At(fClassVersion)));
   }
   TList *GetListOfDataMembers();
   TList *GetListOfBases();
   TList *GetListOfMethods();
   TList *GetListOfRealData() const { return fRealData; }
   TList *GetListOfAllPublicMethods();
   TList *GetListOfAllPublicDataMembers();
   const char *GetImplFileName() const { return fImplFileName; }
   Short_t GetImplFileLine() const { return fImplFileLine; }
   TClass *GetActualClass(const void *object) const;
   TClass *GetBaseClass(const char *classname);
   TClass *GetBaseClass(const TClass *base);
   Int_t GetBaseClassOffset(const TClass *base);
   TClass *GetBaseDataMember(const char *datamember);
   ROOT::DirAutoAdd_t GetDirectoryAutoAdd() const;
   UInt_t GetInstanceCount() const { return fInstanceCount; }
   UInt_t GetHeapInstanceCount() const { return fOnHeap; }
   void GetMenuItems(TList *listitems);
   TList *GetMenuList() const;
   TMethod *GetMethod(const char *method, const char *params);
   TMethod *GetMethodWithPrototype(const char *method, const char *proto);
   TMethod *GetMethodAny(const char *method);
   TMethod *GetMethodAllAny(const char *method);
   Int_t GetNdata();
   ROOT::MergeFunc_t GetMerge() const;
   ROOT::ResetAfterMergeFunc_t GetResetAfterMerge() const;
   ROOT::NewFunc_t GetNew() const;
   ROOT::NewArrFunc_t GetNewArray() const;
   Int_t GetNmethods();
   TRealData *GetRealData(const char *name) const;
   TVirtualRefProxy *GetReferenceProxy() const { return fRefProxy; }
   const ROOT::TSchemaRuleSet *GetSchemaRules() const;
   ROOT::TSchemaRuleSet *GetSchemaRules(Bool_t create = kFALSE);
   const char *GetSharedLibs();
   ShowMembersFunc_t GetShowMembersWrapper() const { return fShowMembers; }
   TClassStreamer *GetStreamer() const;
   ClassStreamerFunc_t GetStreamerFunc() const;
   TObjArray *GetStreamerInfos() const { return fStreamerInfo; }
   TVirtualStreamerInfo *GetStreamerInfo(Int_t version=0) const;
   TVirtualStreamerInfo *GetStreamerInfoAbstractEmulated(Int_t version=0) const;
   const type_info *GetTypeInfo() const { return fTypeInfo; };
   void IgnoreTObjectStreamer(Bool_t ignore=kTRUE);
   Bool_t InheritsFrom(const char *cl) const;
   Bool_t InheritsFrom(const TClass *cl) const;
   void InterpretedShowMembers(void* obj, TMemberInspector &insp);
   Bool_t IsFolder() const { return kTRUE; }
   Bool_t IsLoaded() const;
   Bool_t IsForeign() const;
   Bool_t IsStartingWithTObject() const;
   Bool_t IsTObject() const;
   void ls(Option_t *opt="") const;
   void MakeCustomMenuList();
   void Move(void *arenaFrom, void *arenaTo) const;
   void *New(ENewType defConstructor = kClassNew) const;
   void *New(void *arena, ENewType defConstructor = kClassNew) const;
   void *NewArray(Long_t nElements, ENewType defConstructor = kClassNew) const;
   void *NewArray(Long_t nElements, void *arena, ENewType defConstructor = kClassNew) const;
   virtual void PostLoadCheck();
   Long_t Property() const;
   Int_t ReadBuffer(TBuffer &b, void *pointer, Int_t version, UInt_t start, UInt_t count);
   Int_t ReadBuffer(TBuffer &b, void *pointer);
   void RemoveRef(TClassRef *ref);
   void ReplaceWith(TClass *newcl, Bool_t recurse = kTRUE) const;
   void ResetClassInfo(Long_t tagnum);
   void ResetInstanceCount() { fInstanceCount = fOnHeap = 0; }
   void ResetMenuList();
   Int_t Size() const;
   void SetCanSplit(Int_t splitmode);
   void SetCollectionProxy(const ROOT::TCollectionProxyInfo&);
   void SetContextMenuTitle(const char *title);
   void SetCurrentStreamerInfo(TVirtualStreamerInfo *info);
   void SetGlobalIsA(IsAGlobalFunc_t);
   void SetDeclFile(const char *name, int line) { fDeclFileName = name; fDeclFileLine = line; }
   void SetDelete(ROOT::DelFunc_t deleteFunc);
   void SetDeleteArray(ROOT::DelArrFunc_t deleteArrayFunc);
   void SetDirectoryAutoAdd(ROOT::DirAutoAdd_t dirAutoAddFunc);
   void SetDestructor(ROOT::DesFunc_t destructorFunc);
   void SetImplFileName(const char *implFileName) { fImplFileName = implFileName; }
   void SetMerge(ROOT::MergeFunc_t mergeFunc);
   void SetResetAfterMerge(ROOT::ResetAfterMergeFunc_t resetFunc);
   void SetNew(ROOT::NewFunc_t newFunc);
   void SetNewArray(ROOT::NewArrFunc_t newArrayFunc);
   TVirtualStreamerInfo *SetStreamerInfo(Int_t version, const char *info="");
   void SetUnloaded();
   Int_t WriteBuffer(TBuffer &b, void *pointer, const char *info="");

   void AdoptReferenceProxy(TVirtualRefProxy* proxy);
   void AdoptStreamer(TClassStreamer *strm);
   void AdoptMemberStreamer(const char *name, TMemberStreamer *strm);
   void SetMemberStreamer(const char *name, MemberStreamerFunc_t strm);
   void SetStreamerFunc(ClassStreamerFunc_t strm);

   // Function to retrieve the TClass object and dictionary function
   static void AddClass(TClass *cl);
   static void RemoveClass(TClass *cl);
   static TClass *GetClass(const char *name, Bool_t load = kTRUE, Bool_t silent = kFALSE);
   static TClass *GetClass(const type_info &typeinfo, Bool_t load = kTRUE, Bool_t silent = kFALSE);
   static VoidFuncPtr_t GetDict (const char *cname);
   static VoidFuncPtr_t GetDict (const type_info &info);

   static Int_t AutoBrowse(TObject *obj, TBrowser *browser);
   static ENewType IsCallingNew();
   static TClass *Load(TBuffer &b);
   void Store(TBuffer &b) const;

   // Pseudo-method apply to the 'obj'. In particular those are used to
   // implement TObject like methods for non-TObject classes

   Int_t Browse(void *obj, TBrowser *b) const;
   void DeleteArray(void *ary, Bool_t dtorOnly = kFALSE);
   void Destructor(void *obj, Bool_t dtorOnly = kFALSE);
   void *DynamicCast(const TClass *base, void *obj, Bool_t up = kTRUE);
   Bool_t IsFolder(void *obj) const;
   inline void Streamer(void *obj, TBuffer &b, const TClass *onfile_class = 0) const
   {
      // Inline for performance, skipping one function call.
       (this->*fStreamerImpl)(obj,b,onfile_class);
   }

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TClass::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TClass::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClass.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 389; } //Dictionary containing class information
};

namespace ROOT {


      template <typename T> struct IsPointer { enum { kVal = 0 }; };
      template <typename T> struct IsPointer<T*> { enum { kVal = 1 }; };





   template <typename T> TClass* GetClass( T* /* dummy */) { return TClass::GetClass(typeid(T)); }
   template <typename T> TClass* GetClass(const T* /* dummy */) { return TClass::GetClass(typeid(T)); }


      // This can only be used when the template overload resolution can distringuish between
      // T* and T**
      template <typename T> TClass* GetClass( T** /* dummy */) { return GetClass((T*)0); }
      template <typename T> TClass* GetClass(const T** /* dummy */) { return GetClass((T*)0); }
      template <typename T> TClass* GetClass( T* const* /* dummy */) { return GetClass((T*)0); }
      template <typename T> TClass* GetClass(const T* const* /* dummy */) { return GetClass((T*)0); }


   extern TClass *CreateClass(const char *cname, Version_t id,
                              const char *dfil, const char *ifil,
                              Int_t dl, Int_t il);
}
# 63 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h" 2



# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualTreePlayer.h" 1
// @(#)root/tree:$Id: TVirtualTreePlayer.h 31561 2009-12-04 16:31:47Z brun $
// Author: Rene Brun   30/08/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TVirtualTreePlayer                                                   //
//                                                                      //
// Abstract base class for Tree players.                                //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TClass;
class TTree;
class TH1;
class TTreeFormula;
class TSQLResult;
class TSelector;
class TPrincipal;
class TVirtualIndex;


class TVirtualTreePlayer : public TObject {

private:
   static TClass *fgPlayer; //Pointer to class of Tree player
   static TVirtualTreePlayer *fgCurrent; //Pointer to current Tree player

public:
   TVirtualTreePlayer() { }
   virtual ~TVirtualTreePlayer();
   virtual TVirtualIndex *BuildIndex(const TTree *T, const char *majorname, const char *minorname) = 0;
   virtual TTree *CopyTree(const char *selection, Option_t *option=""
                                   ,Long64_t nentries=1000000000, Long64_t firstentry=0) = 0;
   virtual Long64_t DrawScript(const char *wrapperPrefix,
                                     const char *macrofilename, const char *cutfilename,
                                     Option_t *option, Long64_t nentries, Long64_t firstentry) = 0;
   virtual Long64_t DrawSelect(const char *varexp, const char *selection, Option_t *option
                                     ,Long64_t nentries, Long64_t firstentry) = 0;
   virtual Int_t Fit(const char *formula ,const char *varexp, const char *selection,Option_t *option ,Option_t *goption
                              ,Long64_t nentries, Long64_t firstentry) = 0;
   virtual Int_t GetDimension() const = 0;
   virtual TH1 *GetHistogram() const = 0;
   virtual Int_t GetNfill() const = 0;
   virtual Long64_t GetEntries(const char *) = 0;
   virtual Long64_t GetSelectedRows() const = 0;
   virtual TTreeFormula *GetSelect() const = 0;
   virtual TTreeFormula *GetVar(Int_t) const = 0;
   virtual TTreeFormula *GetVar1() const = 0;
   virtual TTreeFormula *GetVar2() const = 0;
   virtual TTreeFormula *GetVar3() const = 0;
   virtual TTreeFormula *GetVar4() const = 0;
   virtual Double_t *GetVal(Int_t) const = 0;
   virtual Double_t *GetV1() const = 0;
   virtual Double_t *GetV2() const = 0;
   virtual Double_t *GetV3() const = 0;
   virtual Double_t *GetV4() const = 0;
   virtual Double_t *GetW() const = 0;
   virtual Int_t MakeClass(const char *classname, const char *option) = 0;
   virtual Int_t MakeCode(const char *filename) = 0;
   virtual Int_t MakeProxy(const char *classname,
                                    const char *macrofilename = 0, const char *cutfilename = 0,
                                    const char *option = 0, Int_t maxUnrolling = 3) = 0;
   virtual TPrincipal *Principal(const char *varexp="", const char *selection="", Option_t *option="np"
                                    ,Long64_t nentries=1000000000, Long64_t firstentry=0) = 0;
   virtual Long64_t Process(const char *filename,Option_t *option="", Long64_t nentries=1000000000, Long64_t firstentry=0) = 0;
   virtual Long64_t Process(TSelector *selector,Option_t *option="", Long64_t nentries=1000000000, Long64_t firstentry=0) = 0;
   virtual Long64_t Scan(const char *varexp, const char *selection, Option_t *option
                               ,Long64_t nentries, Long64_t firstentry) = 0;
   virtual TSQLResult *Query(const char *varexp, const char *selection, Option_t *option
                                ,Long64_t nentries, Long64_t firstentry) = 0;
   virtual void SetEstimate(Long64_t n) = 0;
   virtual void SetTree(TTree *t) = 0;
   virtual void StartViewer(Int_t ww, Int_t wh) = 0;
   virtual Int_t UnbinnedFit(const char *formula ,const char *varexp, const char *selection,Option_t *option
                                      ,Long64_t nentries, Long64_t firstentry) = 0;
   virtual void UpdateFormulaLeaves() = 0;

   static TVirtualTreePlayer *GetCurrentPlayer();
   static TVirtualTreePlayer *TreePlayer(TTree *obj);
   static void SetPlayer(const char *player);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TVirtualTreePlayer::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TVirtualTreePlayer::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualTreePlayer.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 98; }; //Abstract interface for Tree players
};
# 67 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h" 2


class TBranch;
class TBrowser;
class TFile;
class TDirectory;
class TLeaf;
class TH1;
class TTreeFormula;
class TPolyMarker;
class TEventList;
class TEntryList;
class TList;
class TSQLResult;
class TSelector;
class TPrincipal;
class TFriendElement;
class TCut;
class TVirtualIndex;
class TBranchRef;
class TBasket;
class TStreamerInfo;
class TTreeCloner;
class TFileMergeInfo;

class TTree : public TNamed, public TAttLine, public TAttFill, public TAttMarker {

protected:
   Long64_t fEntries; //  Number of entries
   Long64_t fTotBytes; //  Total number of bytes in all branches before compression
   Long64_t fZipBytes; //  Total number of bytes in all branches after compression
   Long64_t fSavedBytes; //  Number of autosaved bytes
   Long64_t fFlushedBytes; //  Number of autoflushed bytes
   Double_t fWeight; //  Tree weight (see TTree::SetWeight)
   Int_t fTimerInterval; //  Timer interval in milliseconds
   Int_t fScanField; //  Number of runs before prompting in Scan
   Int_t fUpdate; //  Update frequency for EntryLoop
   Int_t fDefaultEntryOffsetLen; //  Initial Length of fEntryOffset table in the basket buffers
   Int_t fNClusterRange; //  Number of Cluster range in addition to the one defined by 'AutoFlush'
   Int_t fMaxClusterRange; //! Memory allocated for the cluster range.
   Long64_t fMaxEntries; //  Maximum number of entries in case of circular buffers
   Long64_t fMaxEntryLoop; //  Maximum number of entries to process
   Long64_t fMaxVirtualSize; //  Maximum total size of buffers kept in memory
   Long64_t fAutoSave; //  Autosave tree when fAutoSave bytes produced
   Long64_t fAutoFlush; //  Autoflush tree when fAutoFlush entries written
   Long64_t fEstimate; //  Number of entries to estimate histogram limits
   Long64_t *fClusterRangeEnd; //[fNClusterRange] Last entry of a cluster range.
   Long64_t *fClusterSize; //[fNClusterRange] Number of entries in each cluster for a given range.
   Long64_t fCacheSize; //! Maximum size of file buffers
   Long64_t fChainOffset; //! Offset of 1st entry of this Tree in a TChain
   Long64_t fReadEntry; //! Number of the entry being processed
   Long64_t fTotalBuffers; //! Total number of bytes in branch buffers
   Int_t fPacketSize; //! Number of entries in one packet for parallel root
   Int_t fNfill; //! Local for EntryLoop
   Int_t fDebug; //! Debug level
   Long64_t fDebugMin; //! First entry number to debug
   Long64_t fDebugMax; //! Last entry number to debug
   Int_t fMakeClass; //! not zero when processing code generated by MakeClass
   Int_t fFileNumber; //! current file number (if file extensions)
   TObject *fNotify; //! Object to be notified when loading a Tree
   TDirectory *fDirectory; //! Pointer to directory holding this tree
   TObjArray fBranches; //  List of Branches
   TObjArray fLeaves; //  Direct pointers to individual branch leaves
   TList *fAliases; //  List of aliases for expressions based on the tree branches.
   TEventList *fEventList; //! Pointer to event selection list (if one)
   TEntryList *fEntryList; //! Pointer to event selection list (if one)
   TArrayD fIndexValues; //  Sorted index values
   TArrayI fIndex; //  Index of sorted values
   TVirtualIndex *fTreeIndex; //  Pointer to the tree Index (if any)
   TList *fFriends; //  pointer to list of friend elements
   TList *fUserInfo; //  pointer to a list of user objects associated to this Tree
   TVirtualTreePlayer *fPlayer; //! Pointer to current Tree player
   TList *fClones; //! List of cloned trees which share our addresses
   TBranchRef *fBranchRef; //  Branch supporting the TRefTable (if any)
   UInt_t fFriendLockStatus; //! Record which method is locking the friend recursion
   TBuffer *fTransientBuffer; //! Pointer to the current transient buffer.

   static Int_t fgBranchStyle; //  Old/New branch style
   static Long64_t fgMaxTreeSize; //  Maximum size of a file containg a Tree

private:
   TTree(const TTree& tt); // not implemented
   TTree& operator=(const TTree& tt); // not implemented

protected:
   void AddClone(TTree*);
   virtual void KeepCircular();
   virtual TBranch *BranchImp(const char* branchname, const char* classname, TClass* ptrClass, void* addobj, Int_t bufsize, Int_t splitlevel);
   virtual TBranch *BranchImp(const char* branchname, TClass* ptrClass, void* addobj, Int_t bufsize, Int_t splitlevel);
   virtual TBranch *BranchImpRef(const char* branchname, const char* classname, TClass* ptrClass, void* addobj, Int_t bufsize, Int_t splitlevel);
   virtual TBranch *BranchImpRef(const char* branchname, TClass* ptrClass, EDataType datatype, void* addobj, Int_t bufsize, Int_t splitlevel);
   virtual Int_t CheckBranchAddressType(TBranch* branch, TClass* ptrClass, EDataType datatype, Bool_t ptr);
   virtual TBranch *BronchExec(const char* name, const char* classname, void* addobj, Bool_t isptrptr, Int_t bufsize, Int_t splitlevel);
   friend TBranch *TTreeBranchImpRef(TTree *tree, const char* branchname, TClass* ptrClass, EDataType datatype, void* addobj, Int_t bufsize, Int_t splitlevel);
   Int_t SetBranchAddressImp(TBranch *branch, void* addr, TBranch** ptr);
   virtual TLeaf *GetLeafImpl(const char* branchname, const char* leafname);

   char GetNewlineValue(istream &inputStream);
   void ImportClusterRanges(TTree *fromtree);

   class TFriendLock {
      // Helper class to prevent infinite recursion in the
      // usage of TTree Friends. Implemented in TTree.cxx.
      TTree *fTree; // Pointer to the locked tree
      UInt_t fMethodBit; // BIT for the locked method
      Bool_t fPrevious; // Previous value of the BIT.

   protected:
      TFriendLock(const TFriendLock&);
      TFriendLock& operator=(const TFriendLock&);

   public:
      TFriendLock(TTree* tree, UInt_t methodbit);
      ~TFriendLock();
   };
   friend class TFriendLock;
   // So that the index class can use TFriendLock:
   friend class TTreeIndex;
   friend class TChainIndex;
   // So that the TTreeCloner can access the protected interfaces
   friend class TTreeCloner;

   // use to update fFriendLockStatus
   enum ELockStatusBits {
      kFindBranch = (1ULL << (0)),
      kFindLeaf = (1ULL << (1)),
      kGetAlias = (1ULL << (2)),
      kGetBranch = (1ULL << (3)),
      kGetEntry = (1ULL << (4)),
      kGetEntryWithIndex = (1ULL << (5)),
      kGetFriend = (1ULL << (6)),
      kGetFriendAlias = (1ULL << (7)),
      kGetLeaf = (1ULL << (8)),
      kLoadTree = (1ULL << (9)),
      kPrint = (1ULL << (10)),
      kRemoveFriend = (1ULL << (11)),
      kSetBranchStatus = (1ULL << (12))
   };

   enum ESetBranchAddressStatus {
      kMissingBranch = -5,
      kInternalError = -4,
      kMissingCompiledCollectionProxy = -3,
      kMismatch = -2,
      kClassMismatch = -1,
      kMatch = 0,
      kMatchConversion = 1,
      kMatchConversionCollection = 2,
      kMakeClass = 3,
      kVoidPtr = 4,
      kNoCheck = 5
   };

public:
   // TTree status bits
   enum {
      kForceRead = (1ULL << (11)),
      kCircular = (1ULL << (12))
   };

   // Split level modifier 
   enum {
      kSplitCollectionOfPointers = 100
   };

   class TClusterIterator
   {
   private:
      TTree *fTree; // TTree upon which we are iterating.
      Int_t fClusterRange; // Which cluster range are we looking at.
      Long64_t fStartEntry; // Where does the cluster start.
      Long64_t fNextEntry; // Where does the cluster end (exclusive).

      Long64_t GetEstimatedClusterSize();

   protected:
      friend class TTree;
      TClusterIterator(TTree *tree, Long64_t firstEntry);

   public:
      // Intentionally used the default copy constructor and default destructor
      // as the TClusterIterator does not own the TTree.
      //  TClusterIterator(const TClusterIterator&);
      // ~TClusterIterator();

      // No public constructors, the iterator must be
      // created via TTree::GetClusterIterator

      // Move on to the next cluster and return the starting entry
      // of this next cluster
      Long64_t Next();

      // Return the start entry of the current cluster.
      Long64_t GetStartEntry() {
         return fStartEntry;
      }

      // Return the first entry of the next cluster.
      Long64_t GetNextEntry() {
         return fNextEntry;
      }

      Long64_t operator()() { return Next(); }
   };

   TTree();
   TTree(const char* name, const char* title, Int_t splitlevel = 99);
   virtual ~TTree();

   virtual void AddBranchToCache(const char *bname, Bool_t subbranches = kFALSE);
   virtual void AddBranchToCache(TBranch *branch, Bool_t subbranches = kFALSE);
   virtual void DropBranchFromCache(const char *bname, Bool_t subbranches = kFALSE);
   virtual void DropBranchFromCache(TBranch *branch, Bool_t subbranches = kFALSE);
   virtual TFriendElement *AddFriend(const char* treename, const char* filename = "");
   virtual TFriendElement *AddFriend(const char* treename, TFile* file);
   virtual TFriendElement *AddFriend(TTree* tree, const char* alias = "", Bool_t warn = kFALSE);
   virtual void AddTotBytes(Int_t tot) { fTotBytes += tot; }
   virtual void AddZipBytes(Int_t zip) { fZipBytes += zip; }
   virtual Long64_t AutoSave(Option_t* option = "");
   virtual Int_t Branch(TCollection* list, Int_t bufsize = 32000, Int_t splitlevel = 99, const char* name = "");
   virtual Int_t Branch(TList* list, Int_t bufsize = 32000, Int_t splitlevel = 99);
   virtual Int_t Branch(const char* folder, Int_t bufsize = 32000, Int_t splitlevel = 99);
   virtual TBranch *Branch(const char* name, void* address, const char* leaflist, Int_t bufsize = 32000);
           TBranch *Branch(const char* name, char* address, const char* leaflist, Int_t bufsize = 32000)
   {
      // Overload to avoid confusion between this signature and the template instance.
      return Branch(name,(void*)address,leaflist,bufsize);
   }
   TBranch *Branch(const char* name, Long_t address, const char* leaflist, Int_t bufsize = 32000)
   {
      // Overload to avoid confusion between this signature and the template instance.
      return Branch(name,(void*)address,leaflist,bufsize);
   }
   TBranch *Branch(const char* name, int address, const char* leaflist, Int_t bufsize = 32000)
   {
      // Overload to avoid confusion between this signature and the template instance.
      return Branch(name,(void*)(Long_t)address,leaflist,bufsize);
   }



   template <class T> TBranch *Branch(const char* name, const char* classname, T* obj, Int_t bufsize = 32000, Int_t splitlevel = 99)
   {
      // See BranchImpRed for details. Here we __ignore
      return BranchImpRef(name, classname, TBuffer::GetClass(typeid(T)), obj, bufsize, splitlevel);
   }
   template <class T> TBranch *Branch(const char* name, const char* classname, T** addobj, Int_t bufsize = 32000, Int_t splitlevel = 99)
   {
      // See BranchImp for details
      return BranchImp(name, classname, TBuffer::GetClass(typeid(T)), addobj, bufsize, splitlevel);
   }
   template <class T> TBranch *Branch(const char* name, T** addobj, Int_t bufsize = 32000, Int_t splitlevel = 99)
   {
      // See BranchImp for details
      return BranchImp(name, TBuffer::GetClass(typeid(T)), addobj, bufsize, splitlevel);
   }
   template <class T> TBranch *Branch(const char* name, T* obj, Int_t bufsize = 32000, Int_t splitlevel = 99)
   {
      // See BranchImp for details
      return BranchImpRef(name, TBuffer::GetClass(typeid(T)), TDataType::GetType(typeid(T)), obj, bufsize, splitlevel);
   }
   virtual TBranch *Bronch(const char* name, const char* classname, void* addobj, Int_t bufsize = 32000, Int_t splitlevel = 99);
   virtual TBranch *BranchOld(const char* name, const char* classname, void* addobj, Int_t bufsize = 32000, Int_t splitlevel = 1);
   virtual TBranch *BranchRef();
   virtual void Browse(TBrowser*);
   virtual Int_t BuildIndex(const char* majorname, const char* minorname = "0");
   TStreamerInfo *BuildStreamerInfo(TClass* cl, void* pointer = 0, Bool_t canOptimize = kTRUE);
   virtual TFile *ChangeFile(TFile* file);
   virtual TTree *CloneTree(Long64_t nentries = -1, Option_t* option = "");
   virtual void CopyAddresses(TTree*,Bool_t undo = kFALSE);
   virtual Long64_t CopyEntries(TTree* tree, Long64_t nentries = -1, Option_t *option = "");
   virtual TTree *CopyTree(const char* selection, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0);
   virtual TBasket *CreateBasket(TBranch*);
   virtual void DirectoryAutoAdd(TDirectory *);
   Int_t Debug() const { return fDebug; }
   virtual void Delete(Option_t* option = ""); // *MENU*
   virtual void Draw(Option_t* opt) { Draw(opt, "", "", 1000000000, 0); }
   virtual Long64_t Draw(const char* varexp, const TCut& selection, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0);
   virtual Long64_t Draw(const char* varexp, const char* selection, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0); // *MENU*
   virtual void DropBaskets();
   virtual void DropBuffers(Int_t nbytes);
   virtual Int_t Fill();
   virtual TBranch *FindBranch(const char* name);
   virtual TLeaf *FindLeaf(const char* name);
   virtual Int_t Fit(const char* funcname, const char* varexp, const char* selection = "", Option_t* option = "", Option_t* goption = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0); // *MENU*
   virtual Int_t FlushBaskets() const;
   virtual const char *GetAlias(const char* aliasName) const;
   virtual Long64_t GetAutoFlush() const {return fAutoFlush;}
   virtual Long64_t GetAutoSave() const {return fAutoSave;}
   virtual TBranch *GetBranch(const char* name);
   virtual TBranchRef *GetBranchRef() const { return fBranchRef; };
   virtual Bool_t GetBranchStatus(const char* branchname) const;
   static Int_t GetBranchStyle();
   virtual Long64_t GetCacheSize() const { return fCacheSize; }
   virtual TClusterIterator GetClusterIterator(Long64_t firstentry);
   virtual Long64_t GetChainEntryNumber(Long64_t entry) const { return entry; }
   virtual Long64_t GetChainOffset() const { return fChainOffset; }
   TFile *GetCurrentFile() const;
           Int_t GetDefaultEntryOffsetLen() const {return fDefaultEntryOffsetLen;}
           Long64_t GetDebugMax() const { return fDebugMax; }
           Long64_t GetDebugMin() const { return fDebugMin; }
   TDirectory *GetDirectory() const { return fDirectory; }
   virtual Long64_t GetEntries() const { return fEntries; }
   virtual Long64_t GetEntries(const char *selection);
   virtual Long64_t GetEntriesFast() const { return fEntries; }
   virtual Long64_t GetEntriesFriend() const;
   virtual Long64_t GetEstimate() const { return fEstimate; }
   virtual Int_t GetEntry(Long64_t entry = 0, Int_t getall = 0);
           Int_t GetEvent(Long64_t entry = 0, Int_t getall = 0) { return GetEntry(entry, getall); }
   virtual Int_t GetEntryWithIndex(Int_t major, Int_t minor = 0);
   virtual Long64_t GetEntryNumberWithBestIndex(Int_t major, Int_t minor = 0) const;
   virtual Long64_t GetEntryNumberWithIndex(Int_t major, Int_t minor = 0) const;
   TEventList *GetEventList() const { return fEventList; }
   virtual TEntryList *GetEntryList();
   virtual Long64_t GetEntryNumber(Long64_t entry) const;
   virtual Int_t GetFileNumber() const { return fFileNumber; }
   virtual TTree *GetFriend(const char*) const;
   virtual const char *GetFriendAlias(TTree*) const;
   TH1 *GetHistogram() { return GetPlayer()->GetHistogram(); }
   virtual Int_t *GetIndex() { return &fIndex.fArray[0]; }
   virtual Double_t *GetIndexValues() { return &fIndexValues.fArray[0]; }
   virtual TIterator *GetIteratorOnAllLeaves(Bool_t dir = kIterForward);
   virtual TLeaf *GetLeaf(const char* branchname, const char* leafname);
   virtual TLeaf *GetLeaf(const char* name);
   virtual TList *GetListOfClones() { return fClones; }
   virtual TObjArray *GetListOfBranches() { return &fBranches; }
   virtual TObjArray *GetListOfLeaves() { return &fLeaves; }
   virtual TList *GetListOfFriends() const { return fFriends; }
   virtual TList *GetListOfAliases() const { return fAliases; }

   // GetMakeClass is left non-virtual for efficiency reason.
   // Making it virtual affects the performance of the I/O
           Int_t GetMakeClass() const { return fMakeClass; }

   virtual Long64_t GetMaxEntryLoop() const { return fMaxEntryLoop; }
   virtual Double_t GetMaximum(const char* columname);
   static Long64_t GetMaxTreeSize();
   virtual Long64_t GetMaxVirtualSize() const { return fMaxVirtualSize; }
   virtual Double_t GetMinimum(const char* columname);
   virtual Int_t GetNbranches() { return fBranches.GetEntriesFast(); }
   TObject *GetNotify() const { return fNotify; }
   TVirtualTreePlayer *GetPlayer();
   virtual Int_t GetPacketSize() const { return fPacketSize; }
   virtual Long64_t GetReadEntry() const { return fReadEntry; }
   virtual Long64_t GetReadEvent() const { return fReadEntry; }
   virtual Int_t GetScanField() const { return fScanField; }
   TTreeFormula *GetSelect() { return GetPlayer()->GetSelect(); }
   virtual Long64_t GetSelectedRows() { return GetPlayer()->GetSelectedRows(); }
   virtual Int_t GetTimerInterval() const { return fTimerInterval; }
           TBuffer* GetTransientBuffer(Int_t size);
   virtual Long64_t GetTotBytes() const { return fTotBytes; }
   virtual TTree *GetTree() const { return const_cast<TTree*>(this); }
   virtual TVirtualIndex *GetTreeIndex() const { return fTreeIndex; }
   virtual Int_t GetTreeNumber() const { return 0; }
   virtual Int_t GetUpdate() const { return fUpdate; }
   virtual TList *GetUserInfo();
   // See TSelectorDraw::GetVar
   TTreeFormula *GetVar(Int_t i) { return GetPlayer()->GetVar(i); }
   // See TSelectorDraw::GetVar
   TTreeFormula *GetVar1() { return GetPlayer()->GetVar1(); }
   // See TSelectorDraw::GetVar
   TTreeFormula *GetVar2() { return GetPlayer()->GetVar2(); }
   // See TSelectorDraw::GetVar
   TTreeFormula *GetVar3() { return GetPlayer()->GetVar3(); }
   // See TSelectorDraw::GetVar
   TTreeFormula *GetVar4() { return GetPlayer()->GetVar4(); }
   // See TSelectorDraw::GetVal
   virtual Double_t *GetVal(Int_t i) { return GetPlayer()->GetVal(i); }
   // See TSelectorDraw::GetVal
   virtual Double_t *GetV1() { return GetPlayer()->GetV1(); }
   // See TSelectorDraw::GetVal
   virtual Double_t *GetV2() { return GetPlayer()->GetV2(); }
   // See TSelectorDraw::GetVal
   virtual Double_t *GetV3() { return GetPlayer()->GetV3(); }
   // See TSelectorDraw::GetVal
   virtual Double_t *GetV4() { return GetPlayer()->GetV4(); }
   virtual Double_t *GetW() { return GetPlayer()->GetW(); }
   virtual Double_t GetWeight() const { return fWeight; }
   virtual Long64_t GetZipBytes() const { return fZipBytes; }
   virtual void IncrementTotalBuffers(Int_t nbytes) { fTotalBuffers += nbytes; }
   Bool_t IsFolder() const { return kTRUE; }
   virtual Int_t LoadBaskets(Long64_t maxmemory = 2000000000);
   virtual Long64_t LoadTree(Long64_t entry);
   virtual Long64_t LoadTreeFriend(Long64_t entry, TTree* T);
   virtual Int_t MakeClass(const char* classname = 0, Option_t* option = "");
   virtual Int_t MakeCode(const char* filename = 0);
   virtual Int_t MakeProxy(const char* classname, const char* macrofilename = 0, const char* cutfilename = 0, const char* option = 0, Int_t maxUnrolling = 3);
   virtual Int_t MakeSelector(const char* selector = 0);
   Bool_t MemoryFull(Int_t nbytes);
   virtual Long64_t Merge(TCollection* list, Option_t* option = "");
   virtual Long64_t Merge(TCollection* list, TFileMergeInfo *info);
   static TTree *MergeTrees(TList* list, Option_t* option = "");
   virtual Bool_t Notify();
   virtual void OptimizeBaskets(ULong64_t maxMemory=10000000, Float_t minComp=1.1, Option_t *option="");
   TPrincipal *Principal(const char* varexp = "", const char* selection = "", Option_t* option = "np", Long64_t nentries = 1000000000, Long64_t firstentry = 0);
   virtual void Print(Option_t* option = "") const; // *MENU*
   virtual void PrintCacheStats(Option_t* option = "") const;
   virtual Long64_t Process(const char* filename, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0); // *MENU*







   virtual Long64_t Project(const char* hname, const char* varexp, const char* selection = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0);
   virtual TSQLResult *Query(const char* varexp = "", const char* selection = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0);
   virtual Long64_t ReadFile(const char* filename, const char* branchDescriptor = "", char delimiter = ' ');
   virtual Long64_t ReadStream(istream& inputStream, const char* branchDescriptor = "", char delimiter = ' ');
   virtual void Refresh();
   virtual void RecursiveRemove(TObject *obj);
   virtual void RemoveFriend(TTree*);
   virtual void Reset(Option_t* option = "");
   virtual void ResetAfterMerge(TFileMergeInfo *);
   virtual void ResetBranchAddress(TBranch *);
   virtual void ResetBranchAddresses();
   virtual Long64_t Scan(const char* varexp = "", const char* selection = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0); // *MENU*
   virtual Bool_t SetAlias(const char* aliasName, const char* aliasFormula);
   virtual void SetAutoSave(Long64_t autos = 300000000);
   virtual void SetAutoFlush(Long64_t autof = -30000000);
   virtual void SetBasketSize(const char* bname, Int_t buffsize = 16000);



   virtual Int_t SetBranchAddress(const char *bname,void *add, TClass *realClass, EDataType datatype, Bool_t isptr);
   virtual Int_t SetBranchAddress(const char *bname,void *add, TBranch **ptr, TClass *realClass, EDataType datatype, Bool_t isptr);
   template <class T> Int_t SetBranchAddress(const char *bname, T **add, TBranch **ptr = 0) {
      TClass *cl = TClass::GetClass(typeid(T));
      EDataType type = kOther_t;
      if (cl==0) type = TDataType::GetType(typeid(T));
      return SetBranchAddress(bname,add,ptr,cl,type,true);
   }

   // This can only be used when the template overload resolution can distringuish between
   // T* and T**
   template <class T> Int_t SetBranchAddress(const char *bname, T *add, TBranch **ptr = 0) {
      TClass *cl = TClass::GetClass(typeid(T));
      EDataType type = kOther_t;
      if (cl==0) type = TDataType::GetType(typeid(T));
      return SetBranchAddress(bname,add,ptr,cl,type,false);
   }

   virtual void SetBranchStatus(const char* bname, Bool_t status = 1, UInt_t* found = 0);
   static void SetBranchStyle(Int_t style = 1); //style=0 for old branch, =1 for new branch style
   virtual void SetCacheSize(Long64_t cachesize = -1);
   virtual void SetCacheEntryRange(Long64_t first, Long64_t last);
   virtual void SetCacheLearnEntries(Int_t n=10);
   virtual void SetChainOffset(Long64_t offset = 0) { fChainOffset=offset; }
   virtual void SetCircular(Long64_t maxEntries);
   virtual void SetDebug(Int_t level = 1, Long64_t min = 0, Long64_t max = 9999999); // *MENU*
   virtual void SetDefaultEntryOffsetLen(Int_t newdefault, Bool_t updateExisting = kFALSE);
   virtual void SetDirectory(TDirectory* dir);
   virtual Long64_t SetEntries(Long64_t n = -1);
   virtual void SetEstimate(Long64_t nentries = 1000000);
   virtual void SetFileNumber(Int_t number = 0);
   virtual void SetEventList(TEventList* list);
   virtual void SetEntryList(TEntryList* list, Option_t *opt="");
   virtual void SetMakeClass(Int_t make);
   virtual void SetMaxEntryLoop(Long64_t maxev = 1000000000) { fMaxEntryLoop = maxev; } // *MENU*
   static void SetMaxTreeSize(Long64_t maxsize = 1900000000);
   virtual void SetMaxVirtualSize(Long64_t size = 0) { fMaxVirtualSize = size; } // *MENU*
   virtual void SetName(const char* name); // *MENU*
   virtual void SetNotify(TObject* obj) { fNotify = obj; }
   virtual void SetObject(const char* name, const char* title);
   virtual void SetParallelUnzip(Bool_t opt=kTRUE, Float_t RelSize=-1);
   virtual void SetScanField(Int_t n = 50) { fScanField = n; } // *MENU*
   virtual void SetTimerInterval(Int_t msec = 333) { fTimerInterval=msec; }
   virtual void SetTreeIndex(TVirtualIndex*index);
   virtual void SetWeight(Double_t w = 1, Option_t* option = "");
   virtual void SetUpdate(Int_t freq = 0) { fUpdate = freq; }
   virtual void Show(Long64_t entry = -1, Int_t lenmax = 20);
   virtual void StartViewer(); // *MENU*
   virtual void StopCacheLearningPhase();
   virtual Int_t UnbinnedFit(const char* funcname, const char* varexp, const char* selection = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0);
   void UseCurrentStyle();
   virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0);
   virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0) const;


   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 19; } static void Dictionary(); virtual TClass *IsA() const { return TTree::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TTree::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 546; } //Tree descriptor (the main ROOT I/O class)
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TTreeFriendLeafIter                                                  //
//                                                                      //
// Iterator on all the leaves in a TTree and its friend                 //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TTreeFriendLeafIter : public TIterator {

protected:
   TTree *fTree; //tree being iterated
   TIterator *fLeafIter; //current leaf sub-iterator.
   TIterator *fTreeIter; //current tree sub-iterator.
   Bool_t fDirection; //iteration direction

   TTreeFriendLeafIter() : fTree(0), fLeafIter(0), fTreeIter(0),
       fDirection(0) { }

public:
   TTreeFriendLeafIter(const TTree* t, Bool_t dir = kIterForward);
   TTreeFriendLeafIter(const TTreeFriendLeafIter &iter);
   ~TTreeFriendLeafIter() { { if (fLeafIter) { delete fLeafIter; fLeafIter = 0; } }; { if (fTreeIter) { delete fTreeIter; fTreeIter = 0; } }; }
   TIterator &operator=(const TIterator &rhs);
   TTreeFriendLeafIter &operator=(const TTreeFriendLeafIter &rhs);

   const TCollection *GetCollection() const { return 0; }
   Option_t *GetOption() const;
   TObject *Next();
   void Reset() { { if (fLeafIter) { delete fLeafIter; fLeafIter = 0; } }; { if (fTreeIter) { delete fTreeIter; fTreeIter = 0; } }; }
   Bool_t operator !=(const TIterator&) const {
      // TODO: Implement me
      return false;
   }
   Bool_t operator !=(const TTreeFriendLeafIter&) const {
      // TODO: Implement me
      return false;
   }
   TObject *operator*() const {
      // TODO: Implement me
      return 0;
   }
   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TTreeFriendLeafIter::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TTreeFriendLeafIter::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 591; } //Linked list iterator
 };
# 26 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 2


class TBrowser;

class TNtuple : public TTree {

protected:
   Int_t fNvar; //  Number of columns
   Float_t *fArgs; //! [fNvar] Array of variables

   virtual Int_t Fill();

private:
   TNtuple(const TNtuple&); // not implemented
   TNtuple& operator=(const TNtuple&); // not implmeneted

public:
   TNtuple();
   TNtuple(const char *name,const char *title, const char *varlist, Int_t bufsize=32000);
   virtual ~TNtuple();

   virtual void Browse(TBrowser *b);
   virtual TTree *CloneTree(Long64_t nentries = -1, Option_t* option = "");
   virtual Int_t Fill(const Float_t *x);
           Int_t Fill(Int_t x0) { return Fill((Float_t)x0); }
           Int_t Fill(Double_t x0) { return Fill((Float_t)x0); }
   virtual Int_t Fill(Float_t x0, Float_t x1=0, Float_t x2=0, Float_t x3=0,
                          Float_t x4=0, Float_t x5=0, Float_t x6=0, Float_t x7=0,
                          Float_t x8=0, Float_t x9=0, Float_t x10=0,
                          Float_t x11=0, Float_t x12=0, Float_t x13=0,
                          Float_t x14=0);
   virtual Int_t GetNvar() const { return fNvar; }
           Float_t *GetArgs() const { return fArgs; }
   virtual Long64_t ReadStream(istream& inputStream, const char *branchDescriptor="", char delimiter = ' ');
   virtual void ResetBranchAddress(TBranch *);
           void ResetBranchAddresses();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TNtuple::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TNtuple::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 63; }; //A simple tree with branches of floats.
};
# 10 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TProfile.h" 1
// @(#)root/hist:$Id: TProfile.h 43802 2012-04-17 15:20:48Z moneta $
// Author: Rene Brun   29/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TProfile                                                             //
//                                                                      //
// Profile histogram class.                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TProfileHelper;

enum EErrorType { kERRORMEAN = 0, kERRORSPREAD, kERRORSPREADI, kERRORSPREADG };

class TF1;

class TProfile : public TH1D {

public:
   friend class TProfileHelper;

protected:
    TArrayD fBinEntries; //number of entries per bin
    EErrorType fErrorMode; //Option to compute errors
    Double_t fYmin; //Lower limit in Y (if set)
    Double_t fYmax; //Upper limit in Y (if set)
    Bool_t fScaling; //!True when TProfile::Scale is called
    Double_t fTsumwy; //Total Sum of weight*Y
    Double_t fTsumwy2; //Total Sum of weight*Y*Y
    TArrayD fBinSumw2; //Array of sum of squares of weights per bin 

static Bool_t fgApproximate; //bin error approximation option

   virtual Int_t BufferFill(Double_t, Double_t) {return -2;} //may not use
   virtual Int_t BufferFill(Double_t x, Double_t y, Double_t w);

   // helper methods for the Merge unification in TProfileHelper
   void SetBins(const Int_t* nbins, const Double_t* range) { SetBins(nbins[0], range[0], range[1]); };
   Int_t Fill(const Double_t* v) { return Fill(v[0], v[1], v[2]); };

private:
   Int_t Fill(Double_t) { MayNotUse("Fill(Double_t)"); return -1;}
   void FillN(Int_t, const Double_t *, const Double_t *, Int_t) { MayNotUse("FillN(Int_t, Double_t*, Double_t*, Int_t)"); }
   Double_t *GetB() {return &fBinEntries.fArray[0];}
   Double_t *GetB2() {return (fBinSumw2.fN ? &fBinSumw2.fArray[0] : 0 ); }
   Double_t *GetW() {return &fArray[0];}
   Double_t *GetW2() {return &fSumw2.fArray[0];}
   void SetBins(Int_t, Double_t, Double_t, Int_t, Double_t, Double_t)
      { MayNotUse("SetBins(Int_t, Double_t, Double_t, Int_t, Double_t, Double_t"); }
   void SetBins(Int_t, const Double_t*, Int_t, const Double_t*)
      { MayNotUse("SetBins(Int_t, const Double_t*, Int_t, const Double_t*"); }
   void SetBins(Int_t, Double_t, Double_t, Int_t, Double_t, Double_t, Int_t, Double_t, Double_t)
      { MayNotUse("SetBins(Int_t, Double_t, Double_t, Int_t, Double_t, Double_t, Int_t, Double_t, Double_t"); }
   void SetBins(Int_t, const Double_t *, Int_t, const Double_t *, Int_t, const Double_t *)
      { MayNotUse("SetBins(Int_t, const Double_t*, Int_t, const Double_t*, Int_t, const Double_t*"); }

public:
   TProfile();
   TProfile(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup, Option_t *option="");
   TProfile(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup,Double_t ylow,Double_t yup,Option_t *option="");
   TProfile(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins, Option_t *option="");
   TProfile(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins, Option_t *option="");
   TProfile(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins, Double_t ylow,Double_t yup, Option_t *option="");
   TProfile(const TProfile &profile);
   virtual ~TProfile();
   virtual Bool_t Add(TF1 *h1, Double_t c1=1, Option_t *option="");
   virtual Bool_t Add(const TH1 *h1, Double_t c1=1);
   virtual Bool_t Add(const TH1 *h1, const TH1 *h2, Double_t c1=1, Double_t c2=1); // *MENU*
   static void Approximate(Bool_t approx=kTRUE);
   virtual Int_t BufferEmpty(Int_t action=0);
           void BuildOptions(Double_t ymin, Double_t ymax, Option_t *option);
   virtual void Copy(TObject &hnew) const;
   virtual Bool_t Divide(TF1 *h1, Double_t c1=1);
   virtual Bool_t Divide(const TH1 *h1);
   virtual Bool_t Divide(const TH1 *h1, const TH1 *h2, Double_t c1=1, Double_t c2=1, Option_t *option=""); // *MENU*
   virtual TH1 *DrawCopy(Option_t *option="") const;
   virtual Int_t Fill(Double_t x, Double_t y);
   virtual Int_t Fill(const char *namex, Double_t y);
   virtual Int_t Fill(Double_t x, Double_t y, Double_t w);
   virtual Int_t Fill(const char *namex, Double_t y, Double_t w);
   virtual void FillN(Int_t ntimes, const Double_t *x, const Double_t *y, const Double_t *w, Int_t stride=1);
   virtual Double_t GetBinContent(Int_t bin) const;
   virtual Double_t GetBinContent(Int_t bin, Int_t) const {return GetBinContent(bin);}
   virtual Double_t GetBinContent(Int_t bin, Int_t, Int_t) const {return GetBinContent(bin);}
   virtual Double_t GetBinError(Int_t bin) const;
   virtual Double_t GetBinError(Int_t bin, Int_t) const {return GetBinError(bin);}
   virtual Double_t GetBinError(Int_t bin, Int_t, Int_t) const {return GetBinError(bin);}
   virtual Double_t GetBinEntries(Int_t bin) const;
   virtual Double_t GetBinEffectiveEntries(Int_t bin) const;
   virtual TArrayD *GetBinSumw2() {return &fBinSumw2;}
   virtual const TArrayD *GetBinSumw2() const {return &fBinSumw2;}
   Option_t *GetErrorOption() const;
   virtual char *GetObjectInfo(Int_t px, Int_t py) const;
   virtual void GetStats(Double_t *stats) const;
   virtual Double_t GetYmin() const {return fYmin;}
   virtual Double_t GetYmax() const {return fYmax;}
   virtual void LabelsDeflate(Option_t *axis="X");
   virtual void LabelsInflate(Option_t *axis="X");
   virtual void LabelsOption(Option_t *option="h", Option_t *axis="X");
   virtual Long64_t Merge(TCollection *list);
   virtual Bool_t Multiply(TF1 *h1, Double_t c1=1);
   virtual Bool_t Multiply(const TH1 *h1);
   virtual Bool_t Multiply(const TH1 *h1, const TH1 *h2, Double_t c1=1, Double_t c2=1, Option_t *option=""); // *MENU*
           TH1D *ProjectionX(const char *name="_px", Option_t *option="e") const;
   virtual void PutStats(Double_t *stats);
           TH1 *Rebin(Int_t ngroup=2, const char*newname="", const Double_t *xbins=0);
   virtual void RebinAxis(Double_t x, TAxis *axis);
   virtual void Reset(Option_t *option="");
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void Scale(Double_t c1=1, Option_t *option="");
   virtual void SetBinEntries(Int_t bin, Double_t w);
   virtual void SetBins(Int_t nbins, Double_t xmin, Double_t xmax);
   virtual void SetBins(Int_t nx, const Double_t *xbins);
   virtual void SetBuffer(Int_t buffersize, Option_t *option="");
   virtual void SetErrorOption(Option_t *option=""); // *MENU*
   virtual void Sumw2();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 6; } static void Dictionary(); virtual TClass *IsA() const { return TProfile::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TProfile::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TProfile.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 135; } //Profile histogram class
};
# 11 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 1
// @(#)root/tree:$Id: TNtuple.h 41666 2011-10-31 19:10:37Z pcanal $
// Author: Rene Brun   06/04/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 12 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TRandom.h" 1
// @(#)root/mathcore:$Id: TRandom.h 32526 2010-03-10 14:56:13Z moneta $
// Author: Rene Brun   15/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/






//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TRandom                                                              //
//                                                                      //
// Simple prototype random number generator class (periodicity = 10**9) //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TRandom : public TNamed {

protected:
   UInt_t fSeed; //Random number generator seed

public:
   TRandom(UInt_t seed=65539);
   virtual ~TRandom();
   virtual Int_t Binomial(Int_t ntot, Double_t prob);
   virtual Double_t BreitWigner(Double_t mean=0, Double_t gamma=1);
   virtual void Circle(Double_t &x, Double_t &y, Double_t r);
   virtual Double_t Exp(Double_t tau);
   virtual Double_t Gaus(Double_t mean=0, Double_t sigma=1);
   virtual UInt_t GetSeed() const {return fSeed;}
   virtual UInt_t Integer(UInt_t imax);
   virtual Double_t Landau(Double_t mean=0, Double_t sigma=1);
   virtual Int_t Poisson(Double_t mean);
   virtual Double_t PoissonD(Double_t mean);
   virtual void Rannor(Float_t &a, Float_t &b);
   virtual void Rannor(Double_t &a, Double_t &b);
   virtual void ReadRandom(const char *filename);
   virtual void SetSeed(UInt_t seed=0);
   virtual Double_t Rndm(Int_t i=0);
   virtual void RndmArray(Int_t n, Float_t *array);
   virtual void RndmArray(Int_t n, Double_t *array);
   virtual void Sphere(Double_t &x, Double_t &y, Double_t &z, Double_t r);
   virtual Double_t Uniform(Double_t x1=1);
   virtual Double_t Uniform(Double_t x1, Double_t x2);
   virtual void WriteRandom(const char *filename);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TRandom::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TRandom::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TRandom.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 59; } //Simple Random number generator (periodicity = 10**9)
};

extern TRandom *gRandom;
# 13 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvas.h" 1
// @(#)root/gpad:$Id: TCanvas.h 29403 2009-07-09 07:17:16Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TCanvas                                                              //
//                                                                      //
// Graphics canvas.                                                     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPad.h" 1
// @(#)root/gpad:$Id: TPad.h 43408 2012-03-20 13:02:53Z couet $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TPad                                                                 //
//                                                                      //
// A Graphics pad.                                                      //
//                                                                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualPad.h" 1
// @(#)root/base:$Id: TVirtualPad.h 42441 2011-12-08 14:15:45Z couet $
// Author: Rene Brun   05/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TVirtualPad                                                          //
//                                                                      //
// Abstract base class for Pads and Canvases                            //
//                                                                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttPad.h" 1
// @(#)root/base:$Id: TAttPad.h 36045 2010-10-03 16:10:52Z brun $
// Author: Rene Brun   04/01/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TAttPad                                                              //
//                                                                      //
// Pad attributes.                                                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////






class TAttPad {
protected:
   Float_t fLeftMargin; //LeftMargin
   Float_t fRightMargin; //RightMargin
   Float_t fBottomMargin; //BottomMargin
   Float_t fTopMargin; //TopMargin
   Float_t fXfile; //X position where to draw the file name
   Float_t fYfile; //Y position where to draw the file name
   Float_t fAfile; //Alignment for the file name
   Float_t fXstat; //X position where to draw the statistics
   Float_t fYstat; //Y position where to draw the statistics
   Float_t fAstat; //Alignment for the statistics
   Color_t fFrameFillColor; //pad frame fill color
   Color_t fFrameLineColor; //pad frame line color
   Style_t fFrameFillStyle; //pad frame fill style
   Style_t fFrameLineStyle; //pad frame line style
   Width_t fFrameLineWidth; //pad frame line width
   Width_t fFrameBorderSize; //pad frame border size
   Int_t fFrameBorderMode; //pad frame border mode

public:
   TAttPad();
   virtual ~TAttPad();
   virtual void Copy(TAttPad &attpad) const;
   Float_t GetBottomMargin() const { return fBottomMargin;}
   Float_t GetLeftMargin() const { return fLeftMargin;}
   Float_t GetRightMargin() const { return fRightMargin;}
   Float_t GetTopMargin() const { return fTopMargin;}
   Float_t GetAfile() const { return fAfile;}
   Float_t GetXfile() const { return fXfile;}
   Float_t GetYfile() const { return fYfile;}
   Float_t GetAstat() const { return fAstat;}
   Float_t GetXstat() const { return fXstat;}
   Float_t GetYstat() const { return fYstat;}
   Color_t GetFrameFillColor() const {return fFrameFillColor;}
   Color_t GetFrameLineColor() const {return fFrameLineColor;}
   Style_t GetFrameFillStyle() const {return fFrameFillStyle;}
   Style_t GetFrameLineStyle() const {return fFrameLineStyle;}
   Width_t GetFrameLineWidth() const {return fFrameLineWidth;}
   Width_t GetFrameBorderSize() const {return fFrameBorderSize;}
   Int_t GetFrameBorderMode() const {return fFrameBorderMode;}
   virtual void Print(Option_t *option="") const;
   virtual void ResetAttPad(Option_t *option="");
   virtual void SetBottomMargin(Float_t bottommargin);
   virtual void SetLeftMargin(Float_t leftmargin);
   virtual void SetRightMargin(Float_t rightmargin);
   virtual void SetTopMargin(Float_t topmargin);
   virtual void SetMargin(Float_t left, Float_t right, Float_t bottom, Float_t top);
   virtual void SetAfile(Float_t afile) { fAfile=afile;}
   virtual void SetXfile(Float_t xfile) { fXfile=xfile;}
   virtual void SetYfile(Float_t yfile) { fYfile=yfile;}
   virtual void SetAstat(Float_t astat) { fAstat=astat;}
   virtual void SetXstat(Float_t xstat) { fXstat=xstat;}
   virtual void SetYstat(Float_t ystat) { fYstat=ystat;}
   void SetFrameFillColor(Color_t color=1) {fFrameFillColor = color;}
   void SetFrameLineColor(Color_t color=1) {fFrameLineColor = color;}
   void SetFrameFillStyle(Style_t styl=0) {fFrameFillStyle = styl;}
   void SetFrameLineStyle(Style_t styl=0) {fFrameLineStyle = styl;}
   void SetFrameLineWidth(Width_t width=1) {fFrameLineWidth = width;}
   void SetFrameBorderSize(Width_t size=1) {fFrameBorderSize = size;}
   void SetFrameBorderMode(Int_t mode=1) {fFrameBorderMode = mode;}

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TAttPad::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TAttPad::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttPad.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 91; }; //Pad attributes
};
# 27 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualPad.h" 2



# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualX.h" 1
// @(#)root/base:$Id: TVirtualX.h 43914 2012-04-23 22:08:24Z rdm $
// Author: Fons Rademakers   3/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TVirtualX                                                            //
//                                                                      //
// Semi-Abstract base class defining a generic interface to the         //
// underlying, low level, graphics system (X11, Win32, MacOS).          //
// An instance of TVirtualX itself defines a batch interface to the     //
// graphics system.                                                     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 37 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualX.h"
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttText.h" 1
// @(#)root/base:$Id: TAttText.h 27861 2009-03-18 08:38:14Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TAttText                                                             //
//                                                                      //
// Text attributes.                                                     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttText.h"
class TAttText {

protected:
   Float_t fTextAngle; //Text angle
   Float_t fTextSize; //Text size
   Short_t fTextAlign; //Text alignment
   Color_t fTextColor; //Text color index
   Font_t fTextFont; //Text font number

public:
   TAttText();
   TAttText(Int_t align, Float_t angle, Color_t color, Style_t font, Float_t tsize);
   virtual ~TAttText();
           void Copy(TAttText &atttext) const;
   virtual Short_t GetTextAlign() const {return fTextAlign;}
   virtual Float_t GetTextAngle() const {return fTextAngle;}
   virtual Color_t GetTextColor() const {return fTextColor;}
   virtual Font_t GetTextFont() const {return fTextFont;}
   virtual Float_t GetTextSize() const {return fTextSize;}
   virtual void Modify();
   virtual void ResetAttText(Option_t *toption="");
   virtual void SaveTextAttributes(ostream &out, const char *name, Int_t alidef=12, Float_t angdef=0, Int_t coldef=1, Int_t fondef=61, Float_t sizdef=1);
   virtual void SetTextAttributes(); // *MENU*
   virtual void SetTextAlign(Short_t align=11) { fTextAlign = align;}
   virtual void SetTextAngle(Float_t tangle=0) { fTextAngle = tangle;} // *MENU*
   virtual void SetTextColor(Color_t tcolor=1) { fTextColor = tcolor;}
   virtual void SetTextFont(Font_t tfont=62) { fTextFont = tfont;}
   virtual void SetTextSize(Float_t tsize=1) { fTextSize = tsize;}
   virtual void SetTextSizePixels(Int_t npixels);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TAttText::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TAttText::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttText.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 62; } //Text attributes
};
# 38 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualX.h" 2





# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/GuiTypes.h" 1
/* @(#)root/base:$Id: GuiTypes.h 42941 2012-02-09 15:55:24Z pcanal $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

// The current heuristics used by CINT to avoid parsing header file for
// which it already has a (compiled) dictionary, is to compare the header
// file name to the list of class names.  CINT will skip the #inclusion
// of headers for compiled classes if they have the same name as a known class.
// Since GuiTypes.h does not declare any class named 'GuiTypes', upon
// seeing #include "GuiTypes.h" in an interpreted script, CINT will parse
// GUiTypes.h and issue the following annoying warnings and error:
/*
 Warning: Re-initialization ignored const kNone /Users/pcanal/root_working/code/root.untouched/include/GuiTypes.h:90:
 Warning: Re-initialization ignored const kCopyFromParent /Users/pcanal/root_working/code/root.untouched/include/GuiTypes.h:91:
 Warning: Re-initialization ignored const kParentRelative /Users/pcanal/root_working/code/root.untouched/include/GuiTypes.h:92:
 Error: Function BIT(0) is not defined in current scope  /Users/pcanal/root_working/code/root.untouched/include/GuiTypes.h:141:
 *** Interpreter error recovered ***
*/
// To avoid these errors, we explicitly hide the content of GuiTypes.h from 
// the CINT interpreter.



//////////////////////////////////////////////////////////////////////////
//                                                                      //
// GuiTypes                                                             //
//                                                                      //
// Types used by the GUI classes.                                       //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





// Basic GUI types
typedef ULong_t Handle_t; //Generic resource handle
typedef Handle_t Display_t; //Display handle
typedef Handle_t Visual_t; //Visual handle
typedef Handle_t Window_t; //Window handle
typedef Handle_t Pixmap_t; //Pixmap handle
typedef Handle_t Drawable_t; //Drawable handle
typedef Handle_t Region_t; //Region handle
typedef Handle_t Colormap_t; //Colormap handle
typedef Handle_t Cursor_t; //Cursor handle
typedef Handle_t FontH_t; //Font handle (as opposed to Font_t which is an index)
typedef Handle_t KeySym_t; //Key symbol handle
typedef Handle_t Atom_t; //WM token
typedef Handle_t GContext_t; //Graphics context handle
typedef Handle_t FontStruct_t; //Pointer to font structure
typedef ULong_t Pixel_t; //Pixel value
typedef UInt_t Mask_t; //Structure mask type
typedef ULong_t Time_t; //Event time

enum EGuiConstants {
   kNotUseful = 0, kWhenMapped = 1, kAlways = 2,
   kIsUnmapped = 0, kIsUnviewable = 1, kIsViewable = 2,
   kInputOutput = 1, kInputOnly = 2,
   kLineSolid = 0, kLineOnOffDash = 1, kLineDoubleDash = 2,
   kCapNotLast = 0, kCapButt = 1, kCapRound = 2, kCapProjecting = 3,
   kJoinMiter = 0, kJoinRound = 1, kJoinBevel = 2,
   kFillSolid = 0, kFillTiled = 1, kFillStippled = 2, kFillOpaqueStippled = 3,
   kEvenOddRule = 0, kWindingRule = 1,
   kClipByChildren = 0, kIncludeInferiors = 1,
   kArcChord = 0, kArcPieSlice = 1
};

// GUI event types. Later merge with EEventType in Button.h and rename to
// EEventTypes. Also rename in that case kGKeyPress to kKeyPress.
enum EGEventType {
   kGKeyPress, kKeyRelease, kButtonPress, kButtonRelease,
   kMotionNotify, kEnterNotify, kLeaveNotify, kFocusIn, kFocusOut,
   kExpose, kConfigureNotify, kMapNotify, kUnmapNotify, kDestroyNotify,
   kClientMessage, kSelectionClear, kSelectionRequest, kSelectionNotify,
   kColormapNotify, kButtonDoubleClick, kOtherEvent
};

enum EGraphicsFunction {
   kGXclear = 0, // 0
   kGXand, // src AND dst
   kGXandReverse, // src AND NOT dst
   kGXcopy, // src
   kGXandInverted, // NOT src AND dst
   kGXnoop, // dst
   kGXxor, // src XOR dst
   kGXor, // src OR dst
   kGXnor, // NOT src AND NOT dst
   kGXequiv, // NOT src XOR dst
   kGXinvert, // NOT dst
   kGXorReverse, // src OR NOT dst
   kGXcopyInverted, // NOT src
   kGXorInverted, // NOT src OR dst
   kGXnand, // NOT src OR NOT dst
   kGXset // 1
};

enum { kDefaultScrollBarWidth = 16 };

const Handle_t kNone = 0;
const Handle_t kCopyFromParent = 0;
const Handle_t kParentRelative = 1;

// Attributes that can be used when creating or changing a window
struct SetWindowAttributes_t {
   Pixmap_t fBackgroundPixmap; // background or kNone or kParentRelative
   ULong_t fBackgroundPixel; // background pixel
   Pixmap_t fBorderPixmap; // border of the window
   ULong_t fBorderPixel; // border pixel value
   UInt_t fBorderWidth; // border width in pixels
   Int_t fBitGravity; // one of bit gravity values
   Int_t fWinGravity; // one of the window gravity values
   Int_t fBackingStore; // kNotUseful, kWhenMapped, kAlways
   ULong_t fBackingPlanes; // planes to be preseved if possible
   ULong_t fBackingPixel; // value to use in restoring planes
   Bool_t fSaveUnder; // should bits under be saved (popups)?
   Long_t fEventMask; // set of events that should be saved
   Long_t fDoNotPropagateMask; // set of events that should not propagate
   Bool_t fOverrideRedirect; // boolean value for override-redirect
   Colormap_t fColormap; // color map to be associated with window
   Cursor_t fCursor; // cursor to be displayed (or kNone)
   Mask_t fMask; // bit mask specifying which fields are valid
};

// Window attributes that can be inquired
struct WindowAttributes_t {
   Int_t fX, fY; // location of window
   Int_t fWidth, fHeight; // width and height of window
   Int_t fBorderWidth; // border width of window
   Int_t fDepth; // depth of window
   void *fVisual; // the associated visual structure
   Window_t fRoot; // root of screen containing window
   Int_t fClass; // kInputOutput, kInputOnly
   Int_t fBitGravity; // one of bit gravity values
   Int_t fWinGravity; // one of the window gravity values
   Int_t fBackingStore; // kNotUseful, kWhenMapped, kAlways
   ULong_t fBackingPlanes; // planes to be preserved if possible
   ULong_t fBackingPixel; // value to be used when restoring planes
   Bool_t fSaveUnder; // boolean, should bits under be saved?
   Colormap_t fColormap; // color map to be associated with window
   Bool_t fMapInstalled; // boolean, is color map currently installed
   Int_t fMapState; // kIsUnmapped, kIsUnviewable, kIsViewable
   Long_t fAllEventMasks; // set of events all people have interest in
   Long_t fYourEventMask; // my event mask
   Long_t fDoNotPropagateMask; // set of events that should not propagate
   Bool_t fOverrideRedirect; // boolean value for override-redirect
   void *fScreen; // back pointer to correct screen
};

// Bits telling which SetWindowAttributes_t fields are valid
const Mask_t kWABackPixmap = (1ULL << (0));
const Mask_t kWABackPixel = (1ULL << (1));
const Mask_t kWABorderPixmap = (1ULL << (2));
const Mask_t kWABorderPixel = (1ULL << (3));
const Mask_t kWABorderWidth = (1ULL << (4));
const Mask_t kWABitGravity = (1ULL << (5));
const Mask_t kWAWinGravity = (1ULL << (6));
const Mask_t kWABackingStore = (1ULL << (7));
const Mask_t kWABackingPlanes = (1ULL << (8));
const Mask_t kWABackingPixel = (1ULL << (9));
const Mask_t kWAOverrideRedirect = (1ULL << (10));
const Mask_t kWASaveUnder = (1ULL << (11));
const Mask_t kWAEventMask = (1ULL << (12));
const Mask_t kWADontPropagate = (1ULL << (13));
const Mask_t kWAColormap = (1ULL << (14));
const Mask_t kWACursor = (1ULL << (15));

// Input event masks, used to set SetWindowAttributes_t::fEventMask
// and to be passed to TVirtualX::SelectInput()
const Mask_t kNoEventMask = 0;
const Mask_t kKeyPressMask = (1ULL << (0));
const Mask_t kKeyReleaseMask = (1ULL << (1));
const Mask_t kButtonPressMask = (1ULL << (2));
const Mask_t kButtonReleaseMask = (1ULL << (3));
const Mask_t kPointerMotionMask = (1ULL << (4));
const Mask_t kButtonMotionMask = (1ULL << (5));
const Mask_t kExposureMask = (1ULL << (6));
const Mask_t kStructureNotifyMask = (1ULL << (7));
const Mask_t kEnterWindowMask = (1ULL << (8));
const Mask_t kLeaveWindowMask = (1ULL << (9));
const Mask_t kFocusChangeMask = (1ULL << (10));
const Mask_t kOwnerGrabButtonMask = (1ULL << (11));
const Mask_t kColormapChangeMask = (1ULL << (12));

// Event structure
struct Event_t {
   EGEventType fType; // of event (see EGEventType)
   Window_t fWindow; // window reported event is relative to
   Time_t fTime; // time event event occured in ms
   Int_t fX, fY; // pointer x, y coordinates in event window
   Int_t fXRoot, fYRoot; // coordinates relative to root
   UInt_t fCode; // key or button code
   UInt_t fState; // key or button mask
   UInt_t fWidth, fHeight; // width and height of exposed area
   Int_t fCount; // if non-zero, at least this many more exposes
   Bool_t fSendEvent; // true if event came from SendEvent
   Handle_t fHandle; // general resource handle (used for atoms or windows)
   Int_t fFormat; // Next fields only used by kClientMessageEvent
   Long_t fUser[5]; // 5 longs can be used by client message events
                                   // NOTE: only [0], [1] and [2] may be used.
                                   // [1] and [2] may contain >32 bit quantities
                                   // (i.e. pointers on 64 bit machines)
};

// Key masks, used as modifiers to GrabButton and GrabKey and
// in Event_t::fState in various key-, mouse-, and button-related events
const Mask_t kKeyShiftMask = (1ULL << (0));
const Mask_t kKeyLockMask = (1ULL << (1));
const Mask_t kKeyControlMask = (1ULL << (2));
const Mask_t kKeyMod1Mask = (1ULL << (3)); // typically the Alt key
const Mask_t kKeyMod2Mask = (1ULL << (4)); // typically mod on numeric keys
const Mask_t kKeyMod3Mask = (1ULL << (5));
const Mask_t kKeyMod4Mask = (1ULL << (6));
const Mask_t kKeyMod5Mask = (1ULL << (7));
const Mask_t kButton1Mask = (1ULL << (8));
const Mask_t kButton2Mask = (1ULL << (9));
const Mask_t kButton3Mask = (1ULL << (10));
const Mask_t kButton4Mask = (1ULL << (11));
const Mask_t kButton5Mask = (1ULL << (12));
const Mask_t kButton6Mask = (1ULL << (13));
const Mask_t kButton7Mask = (1ULL << (14));
const Mask_t kAnyModifier = (1ULL << (15));

// Button names. Used as arguments to GrabButton and as Event_t::fCode
// for button events. Maps to the X11 values.
enum EMouseButton { kAnyButton, kButton1, kButton2, kButton3,
                    kButton4, kButton5, kButton6, kButton7 };

// Some magic X notify modes used in TGTextEntry widget.
// Values must match the ones in /usr/include/X11/X.h. Check when porting.
enum EXMagic { kNotifyNormal = 0, kNotifyGrab = 1, kNotifyUngrab = 2,
               kNotifyPointer = 5, kColormapUninstalled = 0,
               kColormapInstalled = 1 };

// Graphics context structure
struct GCValues_t {
   EGraphicsFunction fFunction; // logical operation
   ULong_t fPlaneMask; // plane mask
   ULong_t fForeground; // foreground pixel
   ULong_t fBackground; // background pixel
   Int_t fLineWidth; // line width
   Int_t fLineStyle; // kLineSolid, kLineOnOffDash, kLineDoubleDash
   Int_t fCapStyle; // kCapNotLast, kCapButt,
                                 // kCapRound, kCapProjecting
   Int_t fJoinStyle; // kJoinMiter, kJoinRound, kJoinBevel
   Int_t fFillStyle; // kFillSolid, kFillTiled,
                                 // kFillStippled, kFillOpaeueStippled
   Int_t fFillRule; // kEvenOddRule, kWindingRule
   Int_t fArcMode; // kArcChord, kArcPieSlice
   Pixmap_t fTile; // tile pixmap for tiling operations
   Pixmap_t fStipple; // stipple 1 plane pixmap for stipping
   Int_t fTsXOrigin; // offset for tile or stipple operations
   Int_t fTsYOrigin;
   FontH_t fFont; // default text font for text operations
   Int_t fSubwindowMode; // kClipByChildren, kIncludeInferiors
   Bool_t fGraphicsExposures; // boolean, should exposures be generated
   Int_t fClipXOrigin; // origin for clipping
   Int_t fClipYOrigin;
   Pixmap_t fClipMask; // bitmap clipping; other calls for rects
   Int_t fDashOffset; // patterned/dashed line information
   Char_t fDashes[8]; // dash pattern list (dash length per byte)
   Int_t fDashLen; // number of dashes in fDashes
   Mask_t fMask; // bit mask specifying which fields are valid

   GCValues_t() : // default constructor
      fFunction (kGXcopy),
      fPlaneMask (0),
      fForeground (0),
      fBackground (1),
      fLineWidth (0),
      fLineStyle (kLineSolid),
      fCapStyle (kCapButt),
      fJoinStyle (kJoinMiter),
      fFillStyle (kFillSolid),
      fFillRule (kEvenOddRule),
      fArcMode (kArcPieSlice),
      fTile (0),
      fStipple (0),
      fTsXOrigin (0),
      fTsYOrigin (0),
      fFont (0),
      fSubwindowMode (kClipByChildren),
      fGraphicsExposures (kTRUE),
      fClipXOrigin (0),
      fClipYOrigin (0),
      fClipMask (0),
      fDashOffset (0),
      fDashLen (2),
      fMask (0)
   {
      for (int i = 2; i < 8; i++) fDashes[i] = 0;
      fDashes[0] = 5; // dashed
      fDashes[1] = 5;
   }
};

// Bits telling which GCValues_t fields are valid
const Mask_t kGCFunction = (1ULL << (0));
const Mask_t kGCPlaneMask = (1ULL << (1));
const Mask_t kGCForeground = (1ULL << (2));
const Mask_t kGCBackground = (1ULL << (3));
const Mask_t kGCLineWidth = (1ULL << (4));
const Mask_t kGCLineStyle = (1ULL << (5));
const Mask_t kGCCapStyle = (1ULL << (6));
const Mask_t kGCJoinStyle = (1ULL << (7));
const Mask_t kGCFillStyle = (1ULL << (8));
const Mask_t kGCFillRule = (1ULL << (9));
const Mask_t kGCTile = (1ULL << (10));
const Mask_t kGCStipple = (1ULL << (11));
const Mask_t kGCTileStipXOrigin = (1ULL << (12));
const Mask_t kGCTileStipYOrigin = (1ULL << (13));
const Mask_t kGCFont = (1ULL << (14));
const Mask_t kGCSubwindowMode = (1ULL << (15));
const Mask_t kGCGraphicsExposures = (1ULL << (16));
const Mask_t kGCClipXOrigin = (1ULL << (17));
const Mask_t kGCClipYOrigin = (1ULL << (18));
const Mask_t kGCClipMask = (1ULL << (19));
const Mask_t kGCDashOffset = (1ULL << (20));
const Mask_t kGCDashList = (1ULL << (21));
const Mask_t kGCArcMode = (1ULL << (22));

struct ColorStruct_t {
   ULong_t fPixel; // color pixel value (index in color table)
   UShort_t fRed; // red component (0..65535)
   UShort_t fGreen; // green component (0..65535)
   UShort_t fBlue; // blue component (0..65535)
   UShort_t fMask; // mask telling which color components are valid
};

// Bits telling which ColorStruct_t fields are valid
const Mask_t kDoRed = (1ULL << (0));
const Mask_t kDoGreen = (1ULL << (1));
const Mask_t kDoBlue = (1ULL << (2));

struct PictureAttributes_t {
   Colormap_t fColormap; // colormap to use
   Int_t fDepth; // depth of window
   UInt_t fWidth; // width of picture
   UInt_t fHeight; // height of picture
   UInt_t fXHotspot; // picture x hotspot coordinate
   UInt_t fYHotspot; // picture y hotspot coordinate
   ULong_t *fPixels; // list of used color pixels (if set use delete[])
   UInt_t fNpixels; // number of used color pixels
   UInt_t fCloseness; // allowable RGB deviation
   Mask_t fMask; // mask specifying which attributes are defined
};

// PictureAttributes_t masks bits
const Mask_t kPAColormap = (1ULL << (0));
const Mask_t kPADepth = (1ULL << (1));
const Mask_t kPASize = (1ULL << (2)); // width and height
const Mask_t kPAHotspot = (1ULL << (3)); // x and y hotspot
const Mask_t kPAReturnPixels = (1ULL << (4));
const Mask_t kPACloseness = (1ULL << (5));

// Initial window mapping state
enum EInitialState {
   kNormalState = (1ULL << (0)),
   kIconicState = (1ULL << (1))
};

// Used for drawing line segments (maps to the X11 XSegments structure)
struct Segment_t {
   Short_t fX1, fY1, fX2, fY2;
};

// Point structure (maps to the X11 XPoint structure)
struct Point_t {
   Short_t fX, fY;
};

// Rectangle structure (maps to the X11 XRectangle structure)
struct Rectangle_t {
   Short_t fX, fY;
   UShort_t fWidth, fHeight;
};

// Atoms used for text cut and paste between windows
const Atom_t kPrimarySelection = 1; // magic values, must match the ones
const Atom_t kCutBuffer = 9; // in /usr/include/X11/Xatom.h
const Int_t kMaxPixel = 32000;
# 44 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualX.h" 2



// WM Atoms are initialized in TGClient
extern Atom_t gWM_DELETE_WINDOW;
extern Atom_t gMOTIF_WM_HINTS;
extern Atom_t gROOT_MESSAGE;

const int kNumCursors = 19;
enum ECursor { kBottomLeft, kBottomRight, kTopLeft, kTopRight,
               kBottomSide, kLeftSide, kTopSide, kRightSide,
               kMove, kCross, kArrowHor, kArrowVer, kHand, kRotate,
               kPointer, kArrowRight, kCaret, kWatch, kNoDrop };

class TPoint;
class TString;
class TGWin32Command;

   class GLUtesselator;




class TVirtualX : public TNamed, public TAttLine, public TAttFill, public TAttText, public TAttMarker {

public:
   enum EDrawMode { kCopy = 1, kXor, kInvert };
   enum EBoxMode { kHollow, kFilled };
   enum ETextMode { kClear, kOpaque };
   enum ETextSetMode { kCheck, kLoad };

protected:
   EDrawMode fDrawMode; //Drawing mode

public:
   TVirtualX(): fDrawMode() { }
   TVirtualX(const char *name, const char *title);
   virtual ~TVirtualX() { }

   virtual Bool_t Init(void *display=0);
   virtual void ClearWindow();
   virtual void ClosePixmap();
   virtual void CloseWindow();
   virtual void CopyPixmap(Int_t wid, Int_t xpos, Int_t ypos);
   virtual void CreateOpenGLContext(Int_t wid=0);
   virtual void DeleteOpenGLContext(Int_t wid=0);
   virtual void DrawBox(Int_t x1, Int_t y1, Int_t x2, Int_t y2, EBoxMode mode);
   virtual void DrawCellArray(Int_t x1, Int_t y1, Int_t x2, Int_t y2,
                                   Int_t nx, Int_t ny, Int_t *ic);
   virtual void DrawFillArea(Int_t n, TPoint *xy);
   virtual void DrawLine(Int_t x1, Int_t y1, Int_t x2, Int_t y2);
   virtual void DrawPolyLine(Int_t n, TPoint *xy);
   virtual void DrawPolyMarker(Int_t n, TPoint *xy);
   virtual void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn, const char *text,
                              ETextMode mode);
   virtual UInt_t ExecCommand(TGWin32Command *code);
   virtual void GetCharacterUp(Float_t &chupx, Float_t &chupy);
   EDrawMode GetDrawMode() { return fDrawMode; }
   virtual Int_t GetDoubleBuffer(Int_t wid);
   virtual void GetGeometry(Int_t wid, Int_t &x, Int_t &y, UInt_t &w, UInt_t &h);
   virtual const char *DisplayName(const char * = 0);
   virtual Handle_t GetNativeEvent() const;
   virtual ULong_t GetPixel(Color_t cindex);
   virtual void GetPlanes(Int_t &nplanes);
   virtual void GetRGB(Int_t index, Float_t &r, Float_t &g, Float_t &b);
   virtual void GetTextExtent(UInt_t &w, UInt_t &h, char *mess);
   virtual Int_t GetFontAscent() const;
   virtual Int_t GetFontDescent() const ;
   virtual Float_t GetTextMagnitude();
   virtual Window_t GetWindowID(Int_t wid);
   virtual Bool_t HasTTFonts() const;
   virtual Int_t InitWindow(ULong_t window);
   virtual Int_t AddWindow(ULong_t qwid, UInt_t w, UInt_t h);
   virtual Int_t AddPixmap(ULong_t pixid, UInt_t w, UInt_t h);
   virtual void RemoveWindow(ULong_t qwid);
   virtual void MoveWindow(Int_t wid, Int_t x, Int_t y);
   virtual Int_t OpenPixmap(UInt_t w, UInt_t h);
   virtual void QueryPointer(Int_t &ix, Int_t &iy);
   virtual Pixmap_t ReadGIF(Int_t x0, Int_t y0, const char *file, Window_t id=0);
   virtual Int_t RequestLocator(Int_t mode, Int_t ctyp, Int_t &x, Int_t &y);
   virtual Int_t RequestString(Int_t x, Int_t y, char *text);
   virtual void RescaleWindow(Int_t wid, UInt_t w, UInt_t h);
   virtual Int_t ResizePixmap(Int_t wid, UInt_t w, UInt_t h);
   virtual void ResizeWindow(Int_t wid);
   virtual void SelectWindow(Int_t wid);
   virtual void SelectPixmap(Int_t qpixid);
   virtual void SetCharacterUp(Float_t chupx, Float_t chupy);
   virtual void SetClipOFF(Int_t wid);
   virtual void SetClipRegion(Int_t wid, Int_t x, Int_t y, UInt_t w, UInt_t h);
   virtual void SetCursor(Int_t win, ECursor cursor);
   virtual void SetDoubleBuffer(Int_t wid, Int_t mode);
   virtual void SetDoubleBufferOFF();
   virtual void SetDoubleBufferON();
   virtual void SetDrawMode(EDrawMode mode);
   virtual void SetFillColor(Color_t cindex);
   virtual void SetFillStyle(Style_t style);
   virtual void SetLineColor(Color_t cindex);
   virtual void SetLineType(Int_t n, Int_t *dash);
   virtual void SetLineStyle(Style_t linestyle);
   virtual void SetLineWidth(Width_t width);
   virtual void SetMarkerColor(Color_t cindex);
   virtual void SetMarkerSize(Float_t markersize);
   virtual void SetMarkerStyle(Style_t markerstyle);
   virtual void SetOpacity(Int_t percent);
   virtual void SetRGB(Int_t cindex, Float_t r, Float_t g, Float_t b);
   virtual void SetTextAlign(Short_t talign=11);
   virtual void SetTextColor(Color_t cindex);
   virtual Int_t SetTextFont(char *fontname, ETextSetMode mode);
   virtual void SetTextFont(Font_t fontnumber);
   virtual void SetTextMagnitude(Float_t mgn);
   virtual void SetTextSize(Float_t textsize);
   virtual void Sync(Int_t mode);
   virtual void UpdateWindow(Int_t mode);
   virtual void Warp(Int_t ix, Int_t iy, Window_t id = 0);
   virtual Int_t WriteGIF(char *name);
   virtual void WritePixmap(Int_t wid, UInt_t w, UInt_t h, char *pxname);
   virtual Window_t GetCurrentWindow() const;
   virtual Int_t SupportsExtension(const char *ext) const;

   //---- Methods used for GUI -----
   virtual void GetWindowAttributes(Window_t id, WindowAttributes_t &attr);
   virtual void MapWindow(Window_t id);
   virtual void MapSubwindows(Window_t id);
   virtual void MapRaised(Window_t id);
   virtual void UnmapWindow(Window_t id);
   virtual void DestroyWindow(Window_t id);
   virtual void DestroySubwindows(Window_t id);
   virtual void RaiseWindow(Window_t id);
   virtual void LowerWindow(Window_t id);
   virtual void MoveWindow(Window_t id, Int_t x, Int_t y);
   virtual void MoveResizeWindow(Window_t id, Int_t x, Int_t y, UInt_t w, UInt_t h);
   virtual void ResizeWindow(Window_t id, UInt_t w, UInt_t h);
   virtual void IconifyWindow(Window_t id);
   virtual Bool_t NeedRedraw(ULong_t tgwindow, Bool_t force);
   virtual void ReparentWindow(Window_t id, Window_t pid, Int_t x, Int_t y);
   virtual void SetWindowBackground(Window_t id, ULong_t color);
   virtual void SetWindowBackgroundPixmap(Window_t id, Pixmap_t pxm);
   virtual Window_t CreateWindow(Window_t parent, Int_t x, Int_t y,
                                     UInt_t w, UInt_t h, UInt_t border,
                                     Int_t depth, UInt_t clss,
                                     void *visual, SetWindowAttributes_t *attr,
                                     UInt_t wtype);
   virtual Int_t OpenDisplay(const char *dpyName);
   virtual void CloseDisplay();
   virtual Display_t GetDisplay() const;
   virtual Visual_t GetVisual() const;
   virtual Int_t GetScreen() const;
   virtual Int_t GetDepth() const;
   virtual UInt_t ScreenWidthMM() const;
   virtual Colormap_t GetColormap() const;
   virtual Atom_t InternAtom(const char *atom_name, Bool_t only_if_exist);
   virtual Window_t GetDefaultRootWindow() const;
   virtual Window_t GetParent(Window_t id) const;
   virtual FontStruct_t LoadQueryFont(const char *font_name);
   virtual FontH_t GetFontHandle(FontStruct_t fs);
   virtual void DeleteFont(FontStruct_t fs);
   virtual GContext_t CreateGC(Drawable_t id, GCValues_t *gval);
   virtual void ChangeGC(GContext_t gc, GCValues_t *gval);
   virtual void CopyGC(GContext_t org, GContext_t dest, Mask_t mask);
   virtual void DeleteGC(GContext_t gc);
   virtual Cursor_t CreateCursor(ECursor cursor);
   virtual void SetCursor(Window_t id, Cursor_t curid);
   virtual Pixmap_t CreatePixmap(Drawable_t id, UInt_t w, UInt_t h);
   virtual Pixmap_t CreatePixmap(Drawable_t id, const char *bitmap, UInt_t width,
                                     UInt_t height, ULong_t forecolor, ULong_t backcolor,
                                     Int_t depth);
   virtual Pixmap_t CreateBitmap(Drawable_t id, const char *bitmap,
                                     UInt_t width, UInt_t height);
   virtual void DeletePixmap(Pixmap_t pmap);
   virtual Bool_t CreatePictureFromFile(Drawable_t id, const char *filename,
                                              Pixmap_t &pict, Pixmap_t &pict_mask,
                                              PictureAttributes_t &attr);
   virtual Bool_t CreatePictureFromData(Drawable_t id, char **data,
                                              Pixmap_t &pict, Pixmap_t &pict_mask,
                                              PictureAttributes_t &attr);
   virtual Pixmap_t CreatePixmapFromData(unsigned char *bits, UInt_t width, UInt_t height);
   virtual Bool_t ReadPictureDataFromFile(const char *filename, char ***ret_data);
   virtual void DeletePictureData(void *data);
   virtual void SetDashes(GContext_t gc, Int_t offset, const char *dash_list,
                                  Int_t n);
   virtual Bool_t ParseColor(Colormap_t cmap, const char *cname, ColorStruct_t &color);
   virtual Bool_t AllocColor(Colormap_t cmap, ColorStruct_t &color);
   virtual void QueryColor(Colormap_t cmap, ColorStruct_t &color);
   virtual void FreeColor(Colormap_t cmap, ULong_t pixel);
   virtual Int_t EventsPending();
   virtual void NextEvent(Event_t &event);
   virtual void Bell(Int_t percent);
   virtual void CopyArea(Drawable_t src, Drawable_t dest, GContext_t gc,
                                 Int_t src_x, Int_t src_y, UInt_t width,
                                 UInt_t height, Int_t dest_x, Int_t dest_y);
   virtual void ChangeWindowAttributes(Window_t id, SetWindowAttributes_t *attr);
   virtual void ChangeProperty(Window_t id, Atom_t property, Atom_t type,
                                       UChar_t *data, Int_t len);
   virtual void DrawLine(Drawable_t id, GContext_t gc, Int_t x1, Int_t y1, Int_t x2, Int_t y2);
   virtual void ClearArea(Window_t id, Int_t x, Int_t y, UInt_t w, UInt_t h);
   virtual Bool_t CheckEvent(Window_t id, EGEventType type, Event_t &ev);
   virtual void SendEvent(Window_t id, Event_t *ev);
   virtual void DispatchClientMessage(UInt_t messageID);
   virtual void WMDeleteNotify(Window_t id);
   virtual void SetKeyAutoRepeat(Bool_t on = kTRUE);
   virtual void GrabKey(Window_t id, Int_t keycode, UInt_t modifier, Bool_t grab = kTRUE);
   virtual void GrabButton(Window_t id, EMouseButton button, UInt_t modifier,
                                   UInt_t evmask, Window_t confine, Cursor_t cursor,
                                   Bool_t grab = kTRUE);
   virtual void GrabPointer(Window_t id, UInt_t evmask, Window_t confine,
                                    Cursor_t cursor, Bool_t grab = kTRUE,
                                    Bool_t owner_events = kTRUE);
   virtual void SetWindowName(Window_t id, char *name);
   virtual void SetIconName(Window_t id, char *name);
   virtual void SetIconPixmap(Window_t id, Pixmap_t pix);
   virtual void SetClassHints(Window_t id, char *className, char *resourceName);
   virtual void SetMWMHints(Window_t id, UInt_t value, UInt_t funcs, UInt_t input);
   virtual void SetWMPosition(Window_t id, Int_t x, Int_t y);
   virtual void SetWMSize(Window_t id, UInt_t w, UInt_t h);
   virtual void SetWMSizeHints(Window_t id, UInt_t wmin, UInt_t hmin,
                                       UInt_t wmax, UInt_t hmax, UInt_t winc, UInt_t hinc);
   virtual void SetWMState(Window_t id, EInitialState state);
   virtual void SetWMTransientHint(Window_t id, Window_t main_id);
   virtual void DrawString(Drawable_t id, GContext_t gc, Int_t x, Int_t y,
                                   const char *s, Int_t len);
   virtual Int_t TextWidth(FontStruct_t font, const char *s, Int_t len);
   virtual void GetFontProperties(FontStruct_t font, Int_t &max_ascent, Int_t &max_descent);
   virtual void GetGCValues(GContext_t gc, GCValues_t &gval);
   virtual FontStruct_t GetFontStruct(FontH_t fh);
   virtual void FreeFontStruct(FontStruct_t fs);
   virtual void ClearWindow(Window_t id);
   virtual Int_t KeysymToKeycode(UInt_t keysym);
   virtual void FillRectangle(Drawable_t id, GContext_t gc, Int_t x, Int_t y,
                                      UInt_t w, UInt_t h);
   virtual void DrawRectangle(Drawable_t id, GContext_t gc, Int_t x, Int_t y,
                                      UInt_t w, UInt_t h);
   virtual void DrawSegments(Drawable_t id, GContext_t gc, Segment_t *seg, Int_t nseg);
   virtual void SelectInput(Window_t id, UInt_t evmask);
   virtual Window_t GetInputFocus();
   virtual void SetInputFocus(Window_t id);
   virtual Window_t GetPrimarySelectionOwner();
   virtual void SetPrimarySelectionOwner(Window_t id);
   virtual void ConvertPrimarySelection(Window_t id, Atom_t clipboard, Time_t when);
   virtual void LookupString(Event_t *event, char *buf, Int_t buflen, UInt_t &keysym);
   virtual void GetPasteBuffer(Window_t id, Atom_t atom, TString &text, Int_t &nchar,
                                       Bool_t del);
   virtual void TranslateCoordinates(Window_t src, Window_t dest, Int_t src_x,Int_t src_y,
                                             Int_t &dest_x, Int_t &dest_y, Window_t &child);
   virtual void GetWindowSize(Drawable_t id, Int_t &x, Int_t &y, UInt_t &w, UInt_t &h);
   virtual void FillPolygon(Window_t id, GContext_t gc, Point_t *points, Int_t npnt);
   virtual void QueryPointer(Window_t id, Window_t &rootw, Window_t &childw,
                                     Int_t &root_x, Int_t &root_y, Int_t &win_x,
                                     Int_t &win_y, UInt_t &mask);
   virtual void SetForeground(GContext_t gc, ULong_t foreground);
   virtual void SetClipRectangles(GContext_t gc, Int_t x, Int_t y, Rectangle_t *recs, Int_t n);
   virtual void Update(Int_t mode = 0);
   virtual Region_t CreateRegion();
   virtual void DestroyRegion(Region_t reg);
   virtual void UnionRectWithRegion(Rectangle_t *rect, Region_t src, Region_t dest);
   virtual Region_t PolygonRegion(Point_t *points, Int_t np, Bool_t winding);
   virtual void UnionRegion(Region_t rega, Region_t regb, Region_t result);
   virtual void IntersectRegion(Region_t rega, Region_t regb, Region_t result);
   virtual void SubtractRegion(Region_t rega, Region_t regb, Region_t result);
   virtual void XorRegion(Region_t rega, Region_t regb, Region_t result);
   virtual Bool_t EmptyRegion(Region_t reg);
   virtual Bool_t PointInRegion(Int_t x, Int_t y, Region_t reg);
   virtual Bool_t EqualRegion(Region_t rega, Region_t regb);
   virtual void GetRegionBox(Region_t reg, Rectangle_t *rect);
   virtual char **ListFonts(const char *fontname, Int_t max, Int_t &count);
   virtual void FreeFontNames(char **fontlist);
   virtual Drawable_t CreateImage(UInt_t width, UInt_t height);
   virtual void GetImageSize(Drawable_t id, UInt_t &width, UInt_t &height);
   virtual void PutPixel(Drawable_t id, Int_t x, Int_t y, ULong_t pixel);
   virtual void PutImage(Drawable_t id, GContext_t gc, Drawable_t img, Int_t dx, Int_t dy,
                                 Int_t x, Int_t y, UInt_t w, UInt_t h);
   virtual void DeleteImage(Drawable_t img);
   virtual unsigned char *GetColorBits(Drawable_t wid, Int_t x = 0, Int_t y = 0, UInt_t w = 0, UInt_t h = 0);
   virtual void ShapeCombineMask(Window_t id, Int_t x, Int_t y, Pixmap_t mask);

   //---- Drag and Drop -----
   virtual void DeleteProperty(Window_t, Atom_t&);
   virtual Int_t GetProperty(Window_t, Atom_t, Long_t, Long_t, Bool_t, Atom_t,
                                    Atom_t*, Int_t*, ULong_t*, ULong_t*, unsigned char**);
   virtual void ChangeActivePointerGrab(Window_t, UInt_t, Cursor_t);
   virtual void ConvertSelection(Window_t, Atom_t&, Atom_t&, Atom_t&, Time_t&);
   virtual Bool_t SetSelectionOwner(Window_t, Atom_t&);
   virtual void ChangeProperties(Window_t id, Atom_t property, Atom_t type,
                                         Int_t format, UChar_t *data, Int_t len);
   virtual void SetDNDAware(Window_t, Atom_t *);
   virtual void SetTypeList(Window_t win, Atom_t prop, Atom_t *typelist);
   virtual Window_t FindRWindow(Window_t win, Window_t dragwin, Window_t input, int x, int y, int maxd);
   virtual Bool_t IsDNDAware(Window_t win, Atom_t *typelist);

   virtual void BeginModalSessionFor(Window_t window);

   virtual Bool_t IsCmdThread() const { return kTRUE; }

   static TVirtualX *&Instance();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TVirtualX::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TVirtualX::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualX.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 338; } //ABC defining a generic interface to graphics system
};





extern TVirtualX *gGXBatch;
# 31 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualPad.h" 2







# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Buttons.h" 1
/* @(#)root/base:$Id: Buttons.h 32308 2010-02-10 08:39:43Z brun $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





enum EEventType {
   kNoEvent = 0,
   kButton1Down = 1, kButton2Down = 2, kButton3Down = 3, kKeyDown = 4,
   kWheelUp = 5, kWheelDown = 6, kButton1Shift = 7, kButton1ShiftMotion = 8,
   kButton1Up = 11, kButton2Up = 12, kButton3Up = 13, kKeyUp = 14,
   kButton1Motion = 21, kButton2Motion = 22, kButton3Motion = 23, kKeyPress = 24,
   kButton1Locate = 41, kButton2Locate = 42, kButton3Locate = 43, kESC = 27,
   kMouseMotion = 51, kMouseEnter = 52, kMouseLeave = 53,
   kButton1Double = 61, kButton2Double = 62, kButton3Double = 63
};

enum EEditMode {
   kPolyLine = 1, kSPolyLine = 2, kPolyGone = 3,
   kSPolyGone = 4, kBox = 5, kDelete = 6,
   kPad = 7, kText = 8, kEditor = 9,
   kExit = 10, kPave = 11, kPaveLabel = 12,
   kPaveText = 13, kPavesText = 14, kEllipse = 15,
   kArc = 16, kLine = 17, kArrow = 18,
   kGraph = 19, kMarker = 20, kPolyMarker= 21,
   kPolyLine3D= 22, kWbox = 23, kGaxis = 24,
   kF1 = 25, kF2 = 26, kF3 = 27,
   kDiamond = 28, kPolyMarker3D = 29, kButton = 101,
   kCutG =100, kCurlyLine =200, kCurlyArc = 201
};
# 39 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualPad.h" 2






// forward declarations
class TAxis;
class TObject;
class TObjLink;
class TView;
class TCanvas;
class TCanvasImp;
class TH1F;
class TFrame;
class TLegend;
class TBox;
class TVirtualViewer3D;

class TVirtualPad : public TObject, public TAttLine, public TAttFill,
                    public TAttPad, public TQObject {

protected:
   Bool_t fResizing; //!true when resizing the pad

   virtual void *GetSender() { return this; } //used to set gTQSender

public:
   TVirtualPad();
   TVirtualPad(const char *name, const char *title, Double_t xlow,
               Double_t ylow, Double_t xup, Double_t yup,
               Color_t color=19, Short_t bordersize=4, Short_t bordermode=1);
   virtual ~TVirtualPad();
   virtual void AbsCoordinates(Bool_t set) = 0;
   virtual Double_t AbsPixeltoX(Int_t px) = 0;
   virtual Double_t AbsPixeltoY(Int_t py) = 0;
   virtual void AddExec(const char *name, const char *command) = 0;
   virtual TLegend *BuildLegend(Double_t x1=0.5, Double_t y1=0.67, Double_t x2=0.88, Double_t y2=0.88, const char *title="") = 0;
   virtual TVirtualPad* cd(Int_t subpadnumber=0) = 0;
   virtual void Clear(Option_t *option="") = 0;
   virtual void Close(Option_t *option="") = 0;
   virtual void CopyPixmap() = 0;
   virtual void CopyPixmaps() = 0;
   virtual void DeleteExec(const char *name) = 0;
   virtual void Divide(Int_t nx=1, Int_t ny=1, Float_t xmargin=0.01, Float_t ymargin=0.01, Int_t color=0) = 0;
   virtual void Draw(Option_t *option="") = 0;
   virtual void DrawClassObject(const TObject *obj, Option_t *option="") = 0;
   virtual TH1F *DrawFrame(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax, const char *title="") = 0;
   virtual void ExecuteEventAxis(Int_t event, Int_t px, Int_t py, TAxis *axis) = 0;
   virtual Short_t GetBorderMode() const = 0;
   virtual Short_t GetBorderSize() const = 0;
   virtual Int_t GetCanvasID() const = 0;
   virtual TCanvasImp *GetCanvasImp() const = 0;
   virtual TCanvas *GetCanvas() const = 0;
   virtual TVirtualPad *GetVirtCanvas() const = 0;
   virtual Int_t GetEvent() const = 0;
   virtual Int_t GetEventX() const = 0;
   virtual Int_t GetEventY() const = 0;
   virtual TFrame *GetFrame() = 0;
   virtual Color_t GetHighLightColor() const = 0;
   virtual Int_t GetNumber() const = 0;
   virtual void GetRange(Double_t &x1, Double_t &y1, Double_t &x2, Double_t &y2) = 0;
   virtual void GetRangeAxis(Double_t &xmin, Double_t &ymin, Double_t &xmax, Double_t &ymax) = 0;
   virtual void GetPadPar(Double_t &xlow, Double_t &ylow, Double_t &xup, Double_t &yup) = 0;
   virtual Double_t GetXlowNDC() const = 0;
   virtual Double_t GetYlowNDC() const = 0;
   virtual Double_t GetWNDC() const = 0;
   virtual Double_t GetHNDC() const = 0;
   virtual UInt_t GetWw() const = 0;
   virtual UInt_t GetWh() const = 0;
   virtual Double_t GetAbsXlowNDC() const = 0;
   virtual Double_t GetAbsYlowNDC() const = 0;
   virtual Double_t GetAbsWNDC() const = 0;
   virtual Double_t GetAbsHNDC() const = 0;
   virtual Double_t GetAspectRatio() const = 0;
   virtual Double_t GetPhi() const = 0;
   virtual Double_t GetTheta() const = 0;
   virtual Double_t GetUxmin() const = 0;
   virtual Double_t GetUymin() const = 0;
   virtual Double_t GetUxmax() const = 0;
   virtual Double_t GetUymax() const = 0;
   virtual Bool_t GetGridx() const = 0;
   virtual Bool_t GetGridy() const = 0;
   virtual Int_t GetTickx() const = 0;
   virtual Int_t GetTicky() const = 0;
   virtual Double_t GetX1() const = 0;
   virtual Double_t GetX2() const = 0;
   virtual Double_t GetY1() const = 0;
   virtual Double_t GetY2() const = 0;
   virtual TList *GetListOfPrimitives() const = 0;
   virtual TList *GetListOfExecs() const = 0;
   virtual TObject *GetPrimitive(const char *name) const = 0;
   virtual TObject *GetSelected() const = 0;
   virtual TVirtualPad *GetPad(Int_t subpadnumber) const = 0;
   virtual TObject *GetPadPointer() const = 0;
   virtual TVirtualPad *GetPadSave() const = 0;
   virtual TVirtualPad *GetSelectedPad() const = 0;
   virtual TView *GetView() const = 0;
   virtual Int_t GetLogx() const = 0;
   virtual Int_t GetLogy() const = 0;
   virtual Int_t GetLogz() const = 0;
   virtual TVirtualPad *GetMother() const = 0;
   virtual const char *GetName() const = 0;
   virtual const char *GetTitle() const = 0;
   virtual Int_t GetPadPaint() const = 0;
   virtual Int_t GetPixmapID() const = 0;
   virtual TObject *GetView3D() const = 0;
   virtual Bool_t HasCrosshair() const = 0;
   virtual void HighLight(Color_t col=kRed, Bool_t set=kTRUE) = 0;
   virtual Bool_t HasFixedAspectRatio() const = 0;
   virtual Bool_t IsBatch() const = 0;
   Bool_t IsBeingResized() const { return fResizing; }
   virtual Bool_t IsEditable() const = 0;
   virtual Bool_t IsModified() const = 0;
   virtual Bool_t IsRetained() const = 0;
   virtual Bool_t IsVertical() const = 0;
   virtual void ls(Option_t *option="") const = 0;
   virtual void Modified(Bool_t flag=1) = 0;
   virtual Bool_t OpaqueMoving() const = 0;
   virtual Bool_t OpaqueResizing() const = 0;
   virtual Double_t PadtoX(Double_t x) const = 0;
   virtual Double_t PadtoY(Double_t y) const = 0;
   virtual void Paint(Option_t *option="") = 0;
   virtual void PaintBorderPS(Double_t xl,Double_t yl,Double_t xt,Double_t yt,Int_t bmode,Int_t bsize,Int_t dark,Int_t light) = 0;
   virtual void PaintBox(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Option_t *option="") = 0;
   virtual void PaintFillArea(Int_t n, Float_t *x, Float_t *y, Option_t *option="") = 0;
   virtual void PaintFillArea(Int_t n, Double_t *x, Double_t *y, Option_t *option="") = 0;
   virtual void PaintPadFrame(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax) = 0;
   virtual void PaintLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2) = 0;
   virtual void PaintLineNDC(Double_t u1, Double_t v1,Double_t u2, Double_t v2) = 0;
   virtual void PaintLine3D(Float_t *p1, Float_t *p2) = 0;
   virtual void PaintLine3D(Double_t *p1, Double_t *p2) = 0;
   virtual void PaintPolyLine(Int_t n, Float_t *x, Float_t *y, Option_t *option="") = 0;
   virtual void PaintPolyLine(Int_t n, Double_t *x, Double_t *y, Option_t *option="") = 0;
   virtual void PaintPolyLine3D(Int_t n, Double_t *p) = 0;
   virtual void PaintPolyLineNDC(Int_t n, Double_t *x, Double_t *y, Option_t *option="") = 0;
   virtual void PaintPolyMarker(Int_t n, Float_t *x, Float_t *y, Option_t *option="") = 0;
   virtual void PaintPolyMarker(Int_t n, Double_t *x, Double_t *y, Option_t *option="") = 0;
   virtual void PaintModified() = 0;
   virtual void PaintText(Double_t x, Double_t y, const char *text) = 0;
   virtual void PaintTextNDC(Double_t u, Double_t v, const char *text) = 0;
   virtual Double_t PixeltoX(Int_t px) = 0;
   virtual Double_t PixeltoY(Int_t py) = 0;
   virtual void Pop() = 0;
   virtual void Print(const char *filename="") const = 0;
   virtual void Print(const char *filename, Option_t *option) = 0;
   virtual void Range(Double_t x1, Double_t y1, Double_t x2, Double_t y2) = 0;
   virtual void RangeAxis(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax) = 0;
   virtual void RecursiveRemove(TObject *obj) = 0;
   virtual void RedrawAxis(Option_t *option="") = 0;
   virtual void ResetView3D(TObject *view=0) = 0;
   virtual void ResizePad(Option_t *option="") = 0;
   virtual void SaveAs(const char *filename="",Option_t *option="") const = 0;
   virtual void SetBatch(Bool_t batch=kTRUE) = 0;
   virtual void SetBorderMode(Short_t bordermode) = 0;
   virtual void SetBorderSize(Short_t bordersize) = 0;
   virtual void SetCanvas(TCanvas *c) = 0;
   virtual void SetCanvasSize(UInt_t ww, UInt_t wh) = 0;
   virtual void SetCrosshair(Int_t crhair=1) = 0;
   virtual void SetCursor(ECursor cursor) = 0;
   virtual void SetDoubleBuffer(Int_t mode=1) = 0;
   virtual void SetEditable(Bool_t mode=kTRUE) = 0;
   virtual void SetFixedAspectRatio(Bool_t fixed = kTRUE) = 0;
   virtual void SetGrid(Int_t valuex = 1, Int_t valuey = 1) = 0;
   virtual void SetGridx(Int_t value = 1) = 0;
   virtual void SetGridy(Int_t value = 1) = 0;
   virtual void SetLogx(Int_t value = 1) = 0;
   virtual void SetLogy(Int_t value = 1) = 0;
   virtual void SetLogz(Int_t value = 1) = 0;
   virtual void SetPad(const char *name, const char *title,
                           Double_t xlow, Double_t ylow, Double_t xup,
                           Double_t yup, Color_t color=35,
                           Short_t bordersize=5, Short_t bordermode=-1) = 0;
   virtual void SetPad(Double_t xlow, Double_t ylow, Double_t xup, Double_t yup) = 0;
   virtual void SetAttFillPS(Color_t color, Style_t style) = 0;
   virtual void SetAttLinePS(Color_t color, Style_t style, Width_t lwidth) = 0;
   virtual void SetAttMarkerPS(Color_t color, Style_t style, Size_t msize) = 0;
   virtual void SetAttTextPS(Int_t align, Float_t angle, Color_t color, Style_t font, Float_t tsize) = 0;
   virtual void SetName(const char *name) = 0;
   virtual void SetSelected(TObject *obj) = 0;
   virtual void SetTicks(Int_t valuex = 1, Int_t valuey = 1) = 0;
   virtual void SetTickx(Int_t value = 1) = 0;
   virtual void SetTicky(Int_t value = 1) = 0;
   virtual void SetTitle(const char *title="") = 0;
   virtual void SetTheta(Double_t theta=30) = 0;
   virtual void SetPhi(Double_t phi=30) = 0;
   virtual void SetToolTipText(const char *text, Long_t delayms = 1000) = 0;
   virtual void SetVertical(Bool_t vert=kTRUE) = 0;
   virtual void SetView(TView *view=0) = 0;
   virtual void SetViewer3D(TVirtualViewer3D * /*viewer3d*/) {}
   virtual TObject *WaitPrimitive(const char *pname="", const char *emode="") = 0;
   virtual void Update() = 0;
   virtual Int_t UtoAbsPixel(Double_t u) const = 0;
   virtual Int_t VtoAbsPixel(Double_t v) const = 0;
   virtual Int_t UtoPixel(Double_t u) const = 0;
   virtual Int_t VtoPixel(Double_t v) const = 0;
   virtual Int_t XtoAbsPixel(Double_t x) const = 0;
   virtual Int_t YtoAbsPixel(Double_t y) const = 0;
   virtual Double_t XtoPad(Double_t x) const = 0;
   virtual Double_t YtoPad(Double_t y) const = 0;
   virtual Int_t XtoPixel(Double_t x) const = 0;
   virtual Int_t YtoPixel(Double_t y) const = 0;

   virtual TObject *CreateToolTip(const TBox *b, const char *text, Long_t delayms) = 0;
   virtual void DeleteToolTip(TObject *tip) = 0;
   virtual void ResetToolTip(TObject *tip) = 0;
   virtual void CloseToolTip(TObject *tip) = 0;

   virtual TVirtualViewer3D *GetViewer3D(Option_t * type = "") = 0;
   virtual Bool_t HasViewer3D() const = 0;
   virtual void ReleaseViewer3D(Option_t * type = "") = 0;

   virtual Int_t GetGLDevice() = 0;
   virtual void SetCopyGLDevice(Bool_t copy) = 0;

   virtual Bool_t PadInSelectionMode() const;
   virtual Bool_t PadInHighlightMode() const;

   virtual void PushTopLevelSelectable(TObject *top);
   virtual void PushSelectableObject(TObject *obj);
   virtual void PopTopLevelSelectable();

   static TVirtualPad *&Pad();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TVirtualPad::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TVirtualPad::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualPad.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 263; } //Abstract base class for Pads and Canvases
};

//
//Small scope-guard class to add/remove object's into pad's stack of selectable objects.
//Does nothing, unless you implement non-standard picking.
//

class TPickerStackGuard {
public:
   TPickerStackGuard(TObject *obj);
   ~TPickerStackGuard();

private:
   TPickerStackGuard(const TPickerStackGuard &rhs);
   TPickerStackGuard &operator = (const TPickerStackGuard &rhs);
};





extern Int_t (*gThreadXAR)(const char *xact, Int_t nb, void **ar, Int_t *iret);
# 27 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPad.h" 2


class TVirtualViewer3D;
class TVirtualPadPainter;
class TBrowser;
class TBox;
class TLegend;

class TPad : public TVirtualPad {

private:
   TObject *fTip; //! tool tip associated with box

protected:
   Double_t fX1; //  X of lower X coordinate
   Double_t fY1; //  Y of lower Y coordinate
   Double_t fX2; //  X of upper X coordinate
   Double_t fY2; //  Y of upper Y coordinate

   Double_t fXtoAbsPixelk; //  Conversion coefficient for X World to absolute pixel
   Double_t fXtoPixelk; //  Conversion coefficient for X World to pixel
   Double_t fXtoPixel; //    xpixel = fXtoPixelk + fXtoPixel*xworld
   Double_t fYtoAbsPixelk; //  Conversion coefficient for Y World to absolute pixel
   Double_t fYtoPixelk; //  Conversion coefficient for Y World to pixel
   Double_t fYtoPixel; //    ypixel = fYtoPixelk + fYtoPixel*yworld

   Double_t fUtoAbsPixelk; //  Conversion coefficient for U NDC to absolute pixel
   Double_t fUtoPixelk; //  Conversion coefficient for U NDC to pixel
   Double_t fUtoPixel; //    xpixel = fUtoPixelk + fUtoPixel*undc
   Double_t fVtoAbsPixelk; //  Conversion coefficient for V NDC to absolute pixel
   Double_t fVtoPixelk; //  Conversion coefficient for V NDC to pixel
   Double_t fVtoPixel; //    ypixel = fVtoPixelk + fVtoPixel*vndc

   Double_t fAbsPixeltoXk; //  Conversion coefficient for absolute pixel to X World
   Double_t fPixeltoXk; //  Conversion coefficient for pixel to X World
   Double_t fPixeltoX; //     xworld = fPixeltoXk + fPixeltoX*xpixel
   Double_t fAbsPixeltoYk; //  Conversion coefficient for absolute pixel to Y World
   Double_t fPixeltoYk; //  Conversion coefficient for pixel to Y World
   Double_t fPixeltoY; //     yworld = fPixeltoYk + fPixeltoY*ypixel

   Double_t fXlowNDC; //  X bottom left corner of pad in NDC [0,1]
   Double_t fYlowNDC; //  Y bottom left corner of pad in NDC [0,1]
   Double_t fWNDC; //  Width of pad along X in NDC
   Double_t fHNDC; //  Height of pad along Y in NDC

   Double_t fAbsXlowNDC; //  Absolute X top left corner of pad in NDC [0,1]
   Double_t fAbsYlowNDC; //  Absolute Y top left corner of pad in NDC [0,1]
   Double_t fAbsWNDC; //  Absolute Width of pad along X in NDC
   Double_t fAbsHNDC; //  Absolute Height of pad along Y in NDC

   Double_t fUxmin; //  Minimum value on the X axis
   Double_t fUymin; //  Minimum value on the Y axis
   Double_t fUxmax; //  Maximum value on the X axis
   Double_t fUymax; //  Maximum value on the Y axis

   Double_t fTheta; //  theta angle to view as lego/surface
   Double_t fPhi; //  phi angle   to view as lego/surface

   Double_t fAspectRatio; //  ratio of w/h in case of fixed ratio

   Int_t fPixmapID; //! Off-screen pixmap identifier
   Int_t fGLDevice; //! OpenGL off-screen pixmap identifier
   Bool_t fCopyGLDevice; //!
   Bool_t fEmbeddedGL; //!
   Int_t fNumber; //  pad number identifier
   Int_t fTickx; //  Set to 1 if tick marks along X
   Int_t fTicky; //  Set to 1 if tick marks along Y
   Int_t fLogx; //  (=0 if X linear scale, =1 if log scale)
   Int_t fLogy; //  (=0 if Y linear scale, =1 if log scale)
   Int_t fLogz; //  (=0 if Z linear scale, =1 if log scale)
   Int_t fPadPaint; //  Set to 1 while painting the pad
   Int_t fCrosshair; //  Crosshair type (0 if no crosshair requested)
   Int_t fCrosshairPos; //  Position of crosshair
   Short_t fBorderSize; //  pad bordersize in pixels
   Short_t fBorderMode; //  Bordermode (-1=down, 0 = no border, 1=up)
   Bool_t fModified; //  Set to true when pad is modified
   Bool_t fGridx; //  Set to true if grid along X
   Bool_t fGridy; //  Set to true if grid along Y
   Bool_t fAbsCoord; //  Use absolute coordinates
   Bool_t fEditable; //  True if canvas is editable
   Bool_t fFixedAspectRatio; //  True if fixed aspect ratio
   TPad *fMother; //! pointer to mother of the list
   TCanvas *fCanvas; //! Pointer to mother canvas
   TList *fPrimitives; //->List of primitives (subpads)
   TList *fExecs; //  List of commands to be executed when a pad event occurs
   TString fName; //  Pad name
   TString fTitle; //  Pad title
   TFrame *fFrame; //! Pointer to 2-D frame (if one exists)
   TView *fView; //! Pointer to 3-D view (if one exists)
   TObject *fPadPointer; //! free pointer
   TObject *fPadView3D; //! 3D View of this TPad
   static Int_t fgMaxPickDistance;//  Maximum Pick Distance

   // 3D Viewer support
   TVirtualViewer3D *fViewer3D; //! Current 3D viewer

   void DestroyExternalViewer3D();
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   virtual void HideToolTip(Int_t event);
   void PaintBorder(Color_t color, Bool_t tops);
   virtual void PaintBorderPS(Double_t xl,Double_t yl,Double_t xt,Double_t yt,Int_t bmode,Int_t bsize,Int_t dark,Int_t light);
   void PaintDate();
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetBatch(Bool_t batch=kTRUE);

private:
   TPad(const TPad &pad); // cannot copy pads, use TObject::Clone()
   TPad &operator=(const TPad &rhs); // idem

   void CopyBackgroundPixmap(Int_t x, Int_t y);
   void CopyBackgroundPixmaps(TPad *start, TPad *stop, Int_t x, Int_t y);

public:
   // TPad status bits
   enum {
      kFraming = (1ULL << (6)),
      kHori = (1ULL << (9)),
      kClipFrame = (1ULL << (10)),
      kPrintingPS = (1ULL << (11)),
      kCannotMove = (1ULL << (12)),
      kClearAfterCR = (1ULL << (14))
   };

   TPad();
   TPad(const char *name, const char *title, Double_t xlow,
        Double_t ylow, Double_t xup, Double_t yup,
        Color_t color=-1, Short_t bordersize=-1, Short_t bordermode=-2);
   virtual ~TPad();
   void AbsCoordinates(Bool_t set) { fAbsCoord = set; }
   Double_t AbsPixeltoX(Int_t px) {return fAbsPixeltoXk + px*fPixeltoX;}
   Double_t AbsPixeltoY(Int_t py) {return fAbsPixeltoYk + py*fPixeltoY;}
   virtual void AbsPixeltoXY(Int_t xpixel, Int_t ypixel, Double_t &x, Double_t &y);
   virtual void AddExec(const char *name, const char *command);
   virtual void AutoExec();
   virtual void Browse(TBrowser *b);
   virtual TLegend *BuildLegend(Double_t x1=0.5, Double_t y1=0.67, Double_t x2=0.88, Double_t y2=0.88, const char *title=""); // *MENU*
   TVirtualPad* cd(Int_t subpadnumber=0); // *MENU*
   void Clear(Option_t *option="");
   virtual Int_t Clip(Float_t *x, Float_t *y, Float_t xclipl, Float_t yclipb, Float_t xclipr, Float_t yclipt);
   virtual Int_t Clip(Double_t *x, Double_t *y, Double_t xclipl, Double_t yclipb, Double_t xclipr, Double_t yclipt);
   virtual Int_t ClippingCode(Double_t x, Double_t y, Double_t xcl1, Double_t ycl1, Double_t xcl2, Double_t ycl2);
   virtual Int_t ClipPolygon(Int_t n, Double_t *x, Double_t *y, Int_t nn, Double_t *xc, Double_t *yc, Double_t xclipl, Double_t yclipb, Double_t xclipr, Double_t yclipt);
   virtual void Close(Option_t *option="");
   virtual void Closed() { Emit("Closed()"); } // *SIGNAL*
   virtual void CopyPixmap();
   virtual void CopyPixmaps();
   virtual void DeleteExec(const char *name);
   virtual void Divide(Int_t nx=1, Int_t ny=1, Float_t xmargin=0.01, Float_t ymargin=0.01, Int_t color=0); // *MENU*
   virtual void DivideSquare(Int_t n, Float_t xmargin=0.01, Float_t ymargin=0.01, Int_t color=0);
   virtual void Draw(Option_t *option="");
   virtual void DrawClassObject(const TObject *obj, Option_t *option="");
   static void DrawColorTable();
   virtual void DrawCrosshair();
   TH1F *DrawFrame(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax, const char *title="");
///   void              DrawLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2);
///   void              DrawLineNDC(Double_t u1, Double_t v1, Double_t u2, Double_t v2);
///   void              DrawText(Double_t x, Double_t y, const char *text);
///   void              DrawTextNDC(Double_t u, Double_t v, const char *text);
   virtual void ExecuteEventAxis(Int_t event, Int_t px, Int_t py, TAxis *axis);
   virtual TObject *FindObject(const char *name) const;
   virtual TObject *FindObject(const TObject *obj) const;
   virtual void UseCurrentStyle(); // *MENU*
   virtual Short_t GetBorderMode() const { return fBorderMode;}
   virtual Short_t GetBorderSize() const { return fBorderSize;}
   Int_t GetCrosshair() const;
   virtual Int_t GetCanvasID() const;
   virtual TCanvasImp *GetCanvasImp() const;
   TFrame *GetFrame();
   virtual Int_t GetEvent() const;
   virtual Int_t GetEventX() const;
   virtual Int_t GetEventY() const;
   virtual Color_t GetHighLightColor() const;
   virtual void GetRange(Double_t &x1, Double_t &y1, Double_t &x2, Double_t &y2);
   virtual void GetRangeAxis(Double_t &xmin, Double_t &ymin, Double_t &xmax, Double_t &ymax);
   virtual void GetPadPar(Double_t &xlow, Double_t &ylow, Double_t &xup, Double_t &yup);
   Double_t GetXlowNDC() const {return fXlowNDC;}
   Double_t GetYlowNDC() const {return fYlowNDC;}
   Double_t GetWNDC() const {return fWNDC;}
   Double_t GetHNDC() const {return fHNDC;}
   virtual UInt_t GetWw() const;
   virtual UInt_t GetWh() const;
   Double_t GetAbsXlowNDC() const {return fAbsXlowNDC;}
   Double_t GetAbsYlowNDC() const {return fAbsYlowNDC;}
   Double_t GetAbsWNDC() const {return fAbsWNDC;}
   Double_t GetAbsHNDC() const {return fAbsHNDC;}
   Double_t GetAspectRatio() const { return fAspectRatio; }
   Double_t GetPhi() const {return fPhi;}
   Double_t GetTheta() const {return fTheta;}
   Double_t GetUxmin() const {return fUxmin;}
   Double_t GetUymin() const {return fUymin;}
   Double_t GetUxmax() const {return fUxmax;}
   Double_t GetUymax() const {return fUymax;}
   Bool_t GetGridx() const {return fGridx;}
   Bool_t GetGridy() const {return fGridy;}
   Int_t GetNumber() const {return fNumber;}
   Int_t GetTickx() const {return fTickx;}
   Int_t GetTicky() const {return fTicky;}
   Double_t GetX1() const { return fX1; }
   Double_t GetX2() const { return fX2; }
   Double_t GetY1() const { return fY1; }
   Double_t GetY2() const { return fY2; }
   static Int_t GetMaxPickDistance();
   TList *GetListOfPrimitives() const {return fPrimitives;}
   TList *GetListOfExecs() const {return fExecs;}
   virtual TObject *GetPrimitive(const char *name) const; //obsolete, use FindObject instead
   virtual TObject *GetSelected() const;
   virtual TVirtualPad *GetPad(Int_t subpadnumber) const;
   virtual TObject *GetPadPointer() const {return fPadPointer;}
   TVirtualPad *GetPadSave() const;
   TVirtualPad *GetSelectedPad() const;
   Int_t GetGLDevice();
   TView *GetView() const {return fView;}
   TObject *GetView3D() const {return fPadView3D;}// Return 3D View of this TPad
   Int_t GetLogx() const {return fLogx;}
   Int_t GetLogy() const {return fLogy;}
   Int_t GetLogz() const {return fLogz;}
   virtual TVirtualPad *GetMother() const {return fMother;}
   const char *GetName() const {return fName.Data();}
   const char *GetTitle() const {return fTitle.Data();}
   virtual TCanvas *GetCanvas() const { return fCanvas; }
   virtual TVirtualPad *GetVirtCanvas() const ;
   virtual TVirtualPadPainter *GetPainter();
   Int_t GetPadPaint() const {return fPadPaint;}
   Int_t GetPixmapID() const {return fPixmapID;}
   ULong_t Hash() const { return fName.Hash(); }
   virtual Bool_t HasCrosshair() const;
   void HighLight(Color_t col=kRed, Bool_t set=kTRUE);
   Bool_t HasFixedAspectRatio() const { return fFixedAspectRatio; }
   virtual Bool_t IsBatch() const;
   virtual Bool_t IsEditable() const {return fEditable;}
   Bool_t IsFolder() const {return kTRUE;}
   Bool_t IsModified() const {return fModified;}
   virtual Bool_t IsRetained() const;
   virtual Bool_t IsVertical() const {return !TestBit(kHori);}
   virtual void ls(Option_t *option="") const;
   void Modified(Bool_t flag=1); // *SIGNAL*
   virtual Bool_t OpaqueMoving() const;
   virtual Bool_t OpaqueResizing() const;
   Double_t PadtoX(Double_t x) const;
   Double_t PadtoY(Double_t y) const;
   virtual void Paint(Option_t *option="");
   void PaintBox(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Option_t *option="");
   void PaintFillArea(Int_t n, Float_t *x, Float_t *y, Option_t *option="");
   void PaintFillArea(Int_t n, Double_t *x, Double_t *y, Option_t *option="");
   void PaintFillAreaHatches(Int_t n, Double_t *x, Double_t *y, Int_t FillStyle);
   void PaintHatches(Double_t dy, Double_t angle, Int_t nn, Double_t *xx, Double_t *yy);
   void PaintPadFrame(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax);
   void PaintLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2);
   void PaintLineNDC(Double_t u1, Double_t v1,Double_t u2, Double_t v2);
   void PaintLine3D(Float_t *p1, Float_t *p2);
   void PaintLine3D(Double_t *p1, Double_t *p2);
   void PaintPolyLine(Int_t n, Float_t *x, Float_t *y, Option_t *option="");
   void PaintPolyLine(Int_t n, Double_t *x, Double_t *y, Option_t *option="");
   void PaintPolyLine3D(Int_t n, Double_t *p);
   void PaintPolyLineNDC(Int_t n, Double_t *x, Double_t *y, Option_t *option="");
   void PaintPolyMarker(Int_t n, Float_t *x, Float_t *y, Option_t *option="");
   void PaintPolyMarker(Int_t n, Double_t *x, Double_t *y, Option_t *option="");
   virtual void PaintModified();
   void PaintText(Double_t x, Double_t y, const char *text);
   void PaintTextNDC(Double_t u, Double_t v, const char *text);
   virtual TPad *Pick(Int_t px, Int_t py, TObjLink *&pickobj);
   Double_t PixeltoX(Int_t px);
   Double_t PixeltoY(Int_t py);
   virtual void PixeltoXY(Int_t xpixel, Int_t ypixel, Double_t &x, Double_t &y);
   virtual void Pop(); // *MENU*
   virtual void Print(const char *filename="") const;
   virtual void Print(const char *filename, Option_t *option);
   virtual void Range(Double_t x1, Double_t y1, Double_t x2, Double_t y2); // *MENU* *ARGS={x1=>fX1,y1=>fY1,x2=>fX2,y2=>fY2}
   virtual void RangeChanged() { Emit("RangeChanged()"); } // *SIGNAL*
   virtual void RangeAxis(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax);
   virtual void RangeAxisChanged() { Emit("RangeAxisChanged()"); } // *SIGNAL*
   virtual void RecursiveRemove(TObject *obj);
   virtual void RedrawAxis(Option_t *option="");
   virtual void ResetView3D(TObject *view=0){fPadView3D=view;}
   virtual void ResizePad(Option_t *option="");
   virtual void SaveAs(const char *filename="",Option_t *option="") const; // *MENU*
   virtual void SetBorderMode(Short_t bordermode) {fBorderMode = bordermode; Modified();} // *MENU*
   virtual void SetBorderSize(Short_t bordersize) {fBorderSize = bordersize; Modified();} // *MENU*
   void SetCanvas(TCanvas *c) { fCanvas = c; }
   virtual void SetCanvasSize(UInt_t ww, UInt_t wh);
   virtual void SetCrosshair(Int_t crhair=1); // *TOGGLE*
   virtual void SetCursor(ECursor cursor);
   virtual void SetDoubleBuffer(Int_t mode=1);
   virtual void SetDrawOption(Option_t *option="");
   virtual void SetEditable(Bool_t mode=kTRUE); // *TOGGLE*
   virtual void SetFixedAspectRatio(Bool_t fixed = kTRUE); // *TOGGLE*
   virtual void SetGrid(Int_t valuex = 1, Int_t valuey = 1) {fGridx = valuex; fGridy = valuey; Modified();}
   virtual void SetGridx(Int_t value = 1) {fGridx = value; Modified();} // *TOGGLE*
   virtual void SetGridy(Int_t value = 1) {fGridy = value; Modified();} // *TOGGLE*
   virtual void SetFillStyle(Style_t fstyle);
   virtual void SetLogx(Int_t value = 1); // *TOGGLE*
   virtual void SetLogy(Int_t value = 1); // *TOGGLE*
   virtual void SetLogz(Int_t value = 1); // *TOGGLE*
   virtual void SetNumber(Int_t number) {fNumber = number;}
   virtual void SetPad(const char *name, const char *title,
                           Double_t xlow, Double_t ylow, Double_t xup,
                           Double_t yup, Color_t color=35,
                           Short_t bordersize=5, Short_t bordermode=-1);
   virtual void SetPad(Double_t xlow, Double_t ylow, Double_t xup, Double_t yup);
   virtual void SetAttFillPS(Color_t color, Style_t style);
   virtual void SetAttLinePS(Color_t color, Style_t style, Width_t lwidth);
   virtual void SetAttMarkerPS(Color_t color, Style_t style, Size_t msize);
   virtual void SetAttTextPS(Int_t align, Float_t angle, Color_t color, Style_t font, Float_t tsize);
   static void SetMaxPickDistance(Int_t maxPick=5);
   virtual void SetName(const char *name) {fName = name;} // *MENU*
   virtual void SetSelected(TObject *obj);
   virtual void SetTicks(Int_t valuex = 1, Int_t valuey = 1) {fTickx = valuex; fTicky = valuey; Modified();}
   virtual void SetTickx(Int_t value = 1) {fTickx = value; Modified();} // *TOGGLE*
   virtual void SetTicky(Int_t value = 1) {fTicky = value; Modified();} // *TOGGLE*
   virtual void SetTitle(const char *title="") {fTitle = title;}
   virtual void SetTheta(Double_t theta=30) {fTheta = theta; Modified();}
   virtual void SetPhi(Double_t phi=30) {fPhi = phi; Modified();}
   virtual void SetToolTipText(const char *text, Long_t delayms = 1000);
   virtual void SetVertical(Bool_t vert=kTRUE);
   virtual void SetView(TView *view = 0);
   virtual void SetViewer3D(TVirtualViewer3D *viewer3d) {fViewer3D = viewer3d;}
   //
   virtual void SetGLDevice(Int_t dev) {fGLDevice = dev;}
   virtual void SetCopyGLDevice(Bool_t copy) {fCopyGLDevice = copy;}
   //
   virtual void Update();
///   virtual void      UpdateFillAttributes(Int_t col, Int_t sty);
///   virtual void      UpdateLineAttributes(Int_t col, Int_t sty, Int_t width);
///   virtual void      UpdateMarkerAttributes(Int_t col, Int_t sty, Float_t msiz);
///   virtual void      UpdateTextAttributes(Int_t align,Float_t angle,Int_t col,Int_t font,Float_t tsize);
   Int_t UtoAbsPixel(Double_t u) const {return Int_t(fUtoAbsPixelk + u*fUtoPixel);}
   Int_t VtoAbsPixel(Double_t v) const {return Int_t(fVtoAbsPixelk + v*fVtoPixel);}
   Int_t UtoPixel(Double_t u) const;
   Int_t VtoPixel(Double_t v) const;
   virtual TObject *WaitPrimitive(const char *pname="", const char *emode="");
   Int_t XtoAbsPixel(Double_t x) const;
   Int_t YtoAbsPixel(Double_t y) const;
   Double_t XtoPad(Double_t x) const;
   Double_t YtoPad(Double_t y) const;
   Int_t XtoPixel(Double_t x) const;
   Int_t YtoPixel(Double_t y) const;
   virtual void XYtoAbsPixel(Double_t x, Double_t y, Int_t &xpixel, Int_t &ypixel) const;
   virtual void XYtoPixel(Double_t x, Double_t y, Int_t &xpixel, Int_t &ypixel) const;

   virtual TObject *CreateToolTip(const TBox *b, const char *text, Long_t delayms);
   virtual void DeleteToolTip(TObject *tip);
   virtual void ResetToolTip(TObject *tip);
   virtual void CloseToolTip(TObject *tip);

   virtual void x3d(Option_t *type=""); // Depreciated

   virtual TVirtualViewer3D *GetViewer3D(Option_t * type = "");
   virtual Bool_t HasViewer3D() const { return (fViewer3D); }
   virtual void ReleaseViewer3D(Option_t * type = "");

   virtual void RecordPave(const TObject *obj); // *SIGNAL*
   virtual void RecordLatex(const TObject *obj); // *SIGNAL*
   virtual void EventPave() { Emit("EventPave()"); } // *SIGNAL*
   virtual void StartEditing() { Emit("StartEditing()"); } // *SIGNAL*

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 10; } static void Dictionary(); virtual TClass *IsA() const { return TPad::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TPad::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPad.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 383; } //A Graphics pad
};


//---- inlines -----------------------------------------------------------------

//______________________________________________________________________________
inline void TPad::Modified(Bool_t flag)
{
   if (!fModified && flag) Emit("Modified()");
   fModified = flag;
}

//______________________________________________________________________________
inline void TPad::AbsPixeltoXY(Int_t xpixel, Int_t ypixel, Double_t &x, Double_t &y)
{
   x = AbsPixeltoX(xpixel);
   y = AbsPixeltoY(ypixel);
}

//______________________________________________________________________________
inline Double_t TPad::PixeltoX(Int_t px)
{
   if (fAbsCoord) return fAbsPixeltoXk + px*fPixeltoX;
   else return fPixeltoXk + px*fPixeltoX;
}

//______________________________________________________________________________
inline Double_t TPad::PixeltoY(Int_t py)
{
   if (fAbsCoord) return fAbsPixeltoYk + py*fPixeltoY;
   else return fPixeltoYk + py*fPixeltoY;
}

//______________________________________________________________________________
inline void TPad::PixeltoXY(Int_t xpixel, Int_t ypixel, Double_t &x, Double_t &y)
{
   x = PixeltoX(xpixel);
   y = PixeltoY(ypixel);
}

//______________________________________________________________________________
inline Int_t TPad::UtoPixel(Double_t u) const
{
   Double_t val;
   if (fAbsCoord) val = fUtoAbsPixelk + u*fUtoPixel;
   else val = u*fUtoPixel;
   if (val < -kMaxPixel) return -kMaxPixel;
   if (val > kMaxPixel) return kMaxPixel;
   return Int_t(val);
}

//______________________________________________________________________________
inline Int_t TPad::VtoPixel(Double_t v) const
{
   Double_t val;
   if (fAbsCoord) val = fVtoAbsPixelk + v*fVtoPixel;
   else val = fVtoPixelk + v*fVtoPixel;
   if (val < -kMaxPixel) return -kMaxPixel;
   if (val > kMaxPixel) return kMaxPixel;
   return Int_t(val);
}

//______________________________________________________________________________
inline Int_t TPad::XtoAbsPixel(Double_t x) const
{
   Double_t val = fXtoAbsPixelk + x*fXtoPixel;
   if (val < -kMaxPixel) return -kMaxPixel;
   if (val > kMaxPixel) return kMaxPixel;
   return Int_t(val);
}

//______________________________________________________________________________
inline Int_t TPad::XtoPixel(Double_t x) const
{
   Double_t val;
   if (fAbsCoord) val = fXtoAbsPixelk + x*fXtoPixel;
   else val = fXtoPixelk + x*fXtoPixel;
   if (val < -kMaxPixel) return -kMaxPixel;
   if (val > kMaxPixel) return kMaxPixel;
   return Int_t(val);
}

//______________________________________________________________________________
inline Int_t TPad::YtoAbsPixel(Double_t y) const
{
   Double_t val = fYtoAbsPixelk + y*fYtoPixel;
   if (val < -kMaxPixel) return -kMaxPixel;
   if (val > kMaxPixel) return kMaxPixel;
   return Int_t(val);
}

//______________________________________________________________________________
inline Int_t TPad::YtoPixel(Double_t y) const
{
   Double_t val;
   if (fAbsCoord) val = fYtoAbsPixelk + y*fYtoPixel;
   else val = fYtoPixelk + y*fYtoPixel;
   if (val < -kMaxPixel) return -kMaxPixel;
   if (val > kMaxPixel) return kMaxPixel;
   return Int_t(val);
}

//______________________________________________________________________________
inline void TPad::XYtoAbsPixel(Double_t x, Double_t y, Int_t &xpixel, Int_t &ypixel) const
{
   xpixel = XtoAbsPixel(x);
   ypixel = YtoAbsPixel(y);
}

//______________________________________________________________________________
inline void TPad::XYtoPixel(Double_t x, Double_t y, Int_t &xpixel, Int_t &ypixel) const
{
   xpixel = XtoPixel(x);
   ypixel = YtoPixel(y);
}

//______________________________________________________________________________
inline void TPad::SetDrawOption(Option_t *)
{ }
# 26 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvas.h" 2



# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttCanvas.h" 1
// @(#)root/gpad:$Id: TAttCanvas.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TAttCanvas                                                           //
//                                                                      //
// Canvas attributes.                                                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TAttCanvas {
private:
   Float_t fXBetween; //X distance between pads
   Float_t fYBetween; //Y distance between pads
   Float_t fTitleFromTop; //Y distance of Global Title from top
   Float_t fXdate; //X position where to draw the date
   Float_t fYdate; //X position where to draw the date
   Float_t fAdate; //Alignment for the date

public:
   TAttCanvas();
   virtual ~TAttCanvas();
   virtual void Copy(TAttCanvas &attcanvas) const;
   Float_t GetAdate() const { return fAdate;}
   Float_t GetTitleFromTop() const { return fTitleFromTop;}
   Float_t GetXBetween() const { return fXBetween;}
   Float_t GetXdate() const { return fXdate;}
   Float_t GetYBetween() const { return fYBetween;}
   Float_t GetYdate() const { return fYdate;}
   virtual void Print(Option_t *option="") const;
   virtual void ResetAttCanvas(Option_t *option="");
   virtual void SetAdate(Float_t adate) { fAdate=adate;}
   virtual void SetTitleFromTop(Float_t titlefromtop)
                                        { fTitleFromTop=titlefromtop;}
   virtual void SetXBetween(Float_t xbetween) { fXBetween=xbetween;}
   virtual void SetXdate(Float_t xdate) { fXdate=xdate;}
   virtual void SetYBetween(Float_t ybetween) { fYBetween=ybetween;}
   virtual void SetYdate(Float_t ydate) { fYdate=ydate;}

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TAttCanvas::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TAttCanvas::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TAttCanvas.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 57; } //Canvas attributes
};
# 30 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvas.h" 2
# 41 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvas.h"
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvasImp.h" 1
// @(#)root/base:$Id: TCanvasImp.h 29403 2009-07-09 07:17:16Z brun $
// Author: Fons Rademakers   16/11/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TCanvasImp                                                           //
//                                                                      //
// ABC describing GUI independent main window (with menubar, scrollbars //
// and a drawing area).                                                 //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TCanvas;


class TCanvasImp {
friend class TCanvas;

protected:
   TCanvas *fCanvas; //TCanvas associated with this implementation

   TCanvasImp(const TCanvasImp& ci)
     : fCanvas(ci.fCanvas) { }
   TCanvasImp& operator=(const TCanvasImp& ci)
     {if(this!=&ci) fCanvas=ci.fCanvas; return *this;}

   virtual void Lock() { }
   virtual void Unlock() { }
   virtual Bool_t IsLocked() { return kFALSE; }

public:
   TCanvasImp(TCanvas *c=0) : fCanvas(c) { }
   TCanvasImp(TCanvas *c, const char *name, UInt_t width, UInt_t height);
   TCanvasImp(TCanvas *c, const char *name, Int_t x, Int_t y, UInt_t width, UInt_t height);
   virtual ~TCanvasImp() { }

   TCanvas *Canvas() const { return fCanvas; }
   virtual void Close() { }
   virtual void ForceUpdate() { }
   virtual UInt_t GetWindowGeometry(Int_t &x, Int_t &y, UInt_t &w, UInt_t &h);
   virtual void Iconify() { }
   virtual Int_t InitWindow() { return 0; }
   virtual void SetStatusText(const char *text = 0, Int_t partidx = 0);
   virtual void SetWindowPosition(Int_t x, Int_t y);
   virtual void SetWindowSize(UInt_t w, UInt_t h);
   virtual void SetWindowTitle(const char *newTitle);
   virtual void SetCanvasSize(UInt_t w, UInt_t h);
   virtual void Show() { }
   virtual void ShowMenuBar(Bool_t show = kTRUE);
   virtual void ShowStatusBar(Bool_t show = kTRUE);
   virtual void RaiseWindow();
   virtual void ReallyDelete();

   virtual void ShowEditor(Bool_t show = kTRUE);
   virtual void ShowToolBar(Bool_t show = kTRUE);
   virtual void ShowToolTips(Bool_t show = kTRUE);

   virtual Bool_t HasEditor() const { return kFALSE; }
   virtual Bool_t HasMenuBar() const { return kFALSE; }
   virtual Bool_t HasStatusBar() const { return kFALSE; }
   virtual Bool_t HasToolBar() const { return kFALSE; }
   virtual Bool_t HasToolTips() const { return kFALSE; }

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TCanvasImp::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TCanvasImp::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvasImp.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 80; } //ABC describing main window protocol
};

inline TCanvasImp::TCanvasImp(TCanvas *c, const char *, UInt_t, UInt_t) : fCanvas(c) { }
inline TCanvasImp::TCanvasImp(TCanvas *c, const char *, Int_t, Int_t, UInt_t, UInt_t) : fCanvas(c) { }
inline UInt_t TCanvasImp::GetWindowGeometry(Int_t &x, Int_t &y, UInt_t &w, UInt_t &h)
               { x = y = 0; w = h = 0; return 0;}
inline void TCanvasImp::SetStatusText(const char *, Int_t) { }
inline void TCanvasImp::SetWindowPosition(Int_t, Int_t) { }
inline void TCanvasImp::SetWindowSize(UInt_t, UInt_t) { }
inline void TCanvasImp::SetWindowTitle(const char *) { }
inline void TCanvasImp::SetCanvasSize(UInt_t, UInt_t) { }
inline void TCanvasImp::ShowMenuBar(Bool_t) { }
inline void TCanvasImp::ShowStatusBar(Bool_t) { }
inline void TCanvasImp::RaiseWindow() { }
inline void TCanvasImp::ReallyDelete() { }

inline void TCanvasImp::ShowEditor(Bool_t) { }
inline void TCanvasImp::ShowToolBar(Bool_t) { }
inline void TCanvasImp::ShowToolTips(Bool_t) { }
# 42 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvas.h" 2


class TContextMenu;
class TControlBar;
class TBrowser;

class TCanvas : public TPad {

friend class TCanvasImp;
friend class TThread;
friend class TInterpreter;

protected:
   TAttCanvas fCatt; //Canvas attributes
   TString fDISPLAY; //Name of destination screen
   Size_t fXsizeUser; //User specified size of canvas along X in CM
   Size_t fYsizeUser; //User specified size of canvas along Y in CM
   Size_t fXsizeReal; //Current size of canvas along X in CM
   Size_t fYsizeReal; //Current size of canvas along Y in CM
   Color_t fHighLightColor; //Highlight color of active pad
   Int_t fDoubleBuffer; //Double buffer flag (0=off, 1=on)
   Int_t fWindowTopX; //Top X position of window (in pixels)
   Int_t fWindowTopY; //Top Y position of window (in pixels)
   UInt_t fWindowWidth; //Width of window (including borders, etc.)
   UInt_t fWindowHeight; //Height of window (including menubar, borders, etc.)
   UInt_t fCw; //Width of the canvas along X (pixels)
   UInt_t fCh; //Height of the canvas along Y (pixels)
   Int_t fEvent; //!Type of current or last handled event
   Int_t fEventX; //!Last X mouse position in canvas
   Int_t fEventY; //!Last Y mouse position in canvas
   Int_t fCanvasID; //!Canvas identifier
   TObject *fSelected; //!Currently selected object
   TObject *fClickSelected; //!Currently click-selected object
   Int_t fSelectedX; //!X of selected object
   Int_t fSelectedY; //!Y of selected object
   TString fSelectedOpt; //!Drawing option of selected object
   TPad *fSelectedPad; //!Pad containing currently selected object
   TPad *fClickSelectedPad;//!Pad containing currently click-selected object
   TPad *fPadSave; //!Pointer to saved pad in HandleInput
   TCanvasImp *fCanvasImp; //!Window system specific canvas implementation
   TContextMenu *fContextMenu; //!Context menu pointer
   Bool_t fBatch; //!True when in batchmode
   Bool_t fUpdating; //!True when Updating the canvas
   Bool_t fRetained; //Retain structure flag
   Bool_t fUseGL; //!True when rendering is with GL
   //
   TVirtualPadPainter *fPainter; //!Canvas (pad) painter.

   static Bool_t fgIsFolder; //Indicates if canvas can be browsed as a folder

private:
   TCanvas(const TCanvas &canvas); // cannot copy canvas, use TObject::Clone()
   TCanvas &operator=(const TCanvas &rhs); // idem
   void Build();
   void CopyPixmaps();
   void DrawEventStatus(Int_t event, Int_t x, Int_t y, TObject *selected);
   void RunAutoExec();

   //Initialize PadPainter.
   void CreatePainter();

protected:
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   //-- used by friend TThread class
   void Init();

public:
   // TCanvas status bits
   enum {
      kShowEventStatus = (1ULL << (15)),
      kAutoExec = (1ULL << (16)),
      kMenuBar = (1ULL << (17)),
      kShowToolBar = (1ULL << (18)),
      kShowEditor = (1ULL << (19)),
      kMoveOpaque = (1ULL << (20)),
      kResizeOpaque = (1ULL << (21)),
      kIsGrayscale = (1ULL << (22)),
      kShowToolTips = (1ULL << (23))
   };

   TCanvas(Bool_t build=kTRUE);
   TCanvas(const char *name, const char *title="", Int_t form=1);
   TCanvas(const char *name, const char *title, Int_t ww, Int_t wh);
   TCanvas(const char *name, const char *title, Int_t wtopx, Int_t wtopy,
           Int_t ww, Int_t wh);
   TCanvas(const char *name, Int_t ww, Int_t wh, Int_t winid);
   virtual ~TCanvas();

   //-- used by friend TThread class
   void Constructor();
   void Constructor(const char *name, const char *title, Int_t form);
   void Constructor(const char *name, const char *title, Int_t ww, Int_t wh);
   void Constructor(const char *name, const char *title,
           Int_t wtopx, Int_t wtopy, Int_t ww, Int_t wh);
   void Destructor();

   TVirtualPad *cd(Int_t subpadnumber=0);
   virtual void Browse(TBrowser *b);
   void Clear(Option_t *option="");
   void Close(Option_t *option="");
   virtual void Delete(Option_t * = "") { MayNotUse("Delete()"); }
   void DisconnectWidget(); // used by TCanvasImp
   virtual void Draw(Option_t *option="");
   virtual TObject *DrawClone(Option_t *option="") const; // *MENU*
   virtual TObject *DrawClonePad(); // *MENU*
   virtual void EditorBar();
   void EmbedInto(Int_t winid, Int_t ww, Int_t wh);
   void EnterLeave(TPad *prevSelPad, TObject *prevSelObj);
   void FeedbackMode(Bool_t set);
   void Flush();
   void UseCurrentStyle(); // *MENU*
   void ForceUpdate() { fCanvasImp->ForceUpdate(); }
   const char *GetDISPLAY() const {return fDISPLAY.Data();}
   TContextMenu *GetContextMenu() const {return fContextMenu;};
   Int_t GetDoubleBuffer() const {return fDoubleBuffer;}
   Int_t GetEvent() const { return fEvent; }
   Int_t GetEventX() const { return fEventX; }
   Int_t GetEventY() const { return fEventY; }
   Color_t GetHighLightColor() const { return fHighLightColor; }
   TVirtualPad *GetPadSave() const { return fPadSave; }
   void ClearPadSave() { fPadSave = 0; }
   TObject *GetSelected() const {return fSelected;}
   TObject *GetClickSelected() const {return fClickSelected;}
   Int_t GetSelectedX() const {return fSelectedX;}
   Int_t GetSelectedY() const {return fSelectedY;}
   Option_t *GetSelectedOpt() const {return fSelectedOpt.Data();}
   TVirtualPad *GetSelectedPad() const { return fSelectedPad; }
   TVirtualPad *GetClickSelectedPad() const { return fClickSelectedPad; }
   Bool_t GetShowEventStatus() const { return TestBit(kShowEventStatus); }
   Bool_t GetShowToolBar() const { return TestBit(kShowToolBar); }
   Bool_t GetShowEditor() const { return TestBit(kShowEditor); }
   Bool_t GetShowToolTips() const { return TestBit(kShowToolTips); }
   Bool_t GetAutoExec() const { return TestBit(kAutoExec); }
   Size_t GetXsizeUser() const {return fXsizeUser;}
   Size_t GetYsizeUser() const {return fYsizeUser;}
   Size_t GetXsizeReal() const {return fXsizeReal;}
   Size_t GetYsizeReal() const {return fYsizeReal;}
   Int_t GetCanvasID() const {return fCanvasID;}
   TCanvasImp *GetCanvasImp() const {return fCanvasImp;}
   Int_t GetWindowTopX();
   Int_t GetWindowTopY();
   UInt_t GetWindowWidth() const { return fWindowWidth; }
   UInt_t GetWindowHeight() const { return fWindowHeight; }
   UInt_t GetWw() const { return fCw; }
   UInt_t GetWh() const { return fCh; }
   virtual void GetCanvasPar(Int_t &wtopx, Int_t &wtopy, UInt_t &ww, UInt_t &wh)
                     {wtopx=GetWindowTopX(); wtopy=fWindowTopY; ww=fWindowWidth; wh=fWindowHeight;}
   virtual void HandleInput(EEventType button, Int_t x, Int_t y);
   Bool_t HasMenuBar() const { return TestBit(kMenuBar); }
   void Iconify() { fCanvasImp->Iconify(); }
   Bool_t IsBatch() const { return fBatch; }
   Bool_t IsFolder() const;
   Bool_t IsGrayscale();
   Bool_t IsRetained() const { return fRetained; }
   virtual void ls(Option_t *option="") const;
   void MoveOpaque(Int_t set=1);
   Bool_t OpaqueMoving() const { return TestBit(kMoveOpaque); }
   Bool_t OpaqueResizing() const { return TestBit(kResizeOpaque); }
   virtual void Paint(Option_t *option="");
   virtual TPad *Pick(Int_t px, Int_t py, TObjLink *&pickobj) { return TPad::Pick(px, py, pickobj); }
   virtual TPad *Pick(Int_t px, Int_t py, TObject *prevSelObj);
   virtual void Picked(TPad *selpad, TObject *selected, Int_t event); // *SIGNAL*
   virtual void ProcessedEvent(Int_t event, Int_t x, Int_t y, TObject *selected); // *SIGNAL*
   virtual void Selected(TVirtualPad *pad, TObject *obj, Int_t event); // *SIGNAL*
   virtual void Cleared(TVirtualPad *pad); // *SIGNAL*
   virtual void Closed(); // *SIGNAL*
   void RaiseWindow() { fCanvasImp->RaiseWindow(); }
   virtual void Resize(Option_t *option="");
   void ResizeOpaque(Int_t set=1);
   void SaveSource(const char *filename="", Option_t *option="");
   void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetCursor(ECursor cursor);
   virtual void SetDoubleBuffer(Int_t mode=1);
   virtual void SetFixedAspectRatio(Bool_t fixed = kTRUE); // *TOGGLE*
   void SetGrayscale(Bool_t set = kTRUE); // *TOGGLE* *GETTER=IsGrayscale
   void SetWindowPosition(Int_t x, Int_t y) { fCanvasImp->SetWindowPosition(x, y); }
   void SetWindowSize(UInt_t ww, UInt_t wh) { fCanvasImp->SetWindowSize(ww, wh); }
   void SetCanvasSize(UInt_t ww, UInt_t wh); // *MENU*
   void SetHighLightColor(Color_t col) { fHighLightColor = col; }
   void SetSelected(TObject *obj);
   void SetClickSelected(TObject *obj) { fClickSelected = obj; }
   void SetSelectedPad(TPad *pad) { fSelectedPad = pad; }
   void SetClickSelectedPad(TPad *pad) { fClickSelectedPad = pad; }
   void Show() { fCanvasImp->Show(); }
   virtual void Size(Float_t xsizeuser=0, Float_t ysizeuser=0);
   void SetBatch(Bool_t batch=kTRUE);
   static void SetFolder(Bool_t isfolder=kTRUE);
   void SetPadSave(TPad *pad) {fPadSave = pad;}
   void SetRetained(Bool_t retained=kTRUE) { fRetained=retained;}
   void SetTitle(const char *title="");
   virtual void ToggleEventStatus();
   virtual void ToggleAutoExec();
   virtual void ToggleToolBar();
   virtual void ToggleEditor();
   virtual void ToggleToolTips();
   virtual void Update();
   //Still need this.
   Bool_t UseGL() const { return fUseGL; }
   void SetSupportGL(Bool_t support) {fUseGL = support;}

   //Name is GetPainter, not GetPadPainter
   //to avoid name hiding and confusion.
   //GetPadPainter and GetPainter are non-virtual (no need, in fact).
   TVirtualPadPainter *GetCanvasPainter();

   static TCanvas *MakeDefCanvas();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 7; } static void Dictionary(); virtual TClass *IsA() const { return TCanvas::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TCanvas::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvas.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 249; } //Graphics canvas
};
# 14 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLine.h" 1
// @(#)root/graf:$Id: TLine.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TLine                                                                //
//                                                                      //
// A line segment.                                                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 33 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLine.h"
class TLine : public TObject, public TAttLine {

protected:
   Double_t fX1; //X of 1st point
   Double_t fY1; //Y of 1st point
   Double_t fX2; //X of 2nd point
   Double_t fY2; //Y of 2nd point

public:
   // TLine status bits
   enum {
      kLineNDC = (1ULL << (14)), // Use NDC coordinates
      kVertical = (1ULL << (15)), // Line is vertical
      kHorizontal = (1ULL << (16)) // Line is horizontal
   };

   TLine();
   TLine(Double_t x1, Double_t y1,Double_t x2, Double_t y2);
   TLine(const TLine &line);
   virtual ~TLine();

   void Copy(TObject &line) const;
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual TLine *DrawLine(Double_t x1, Double_t y1,Double_t x2, Double_t y2);
   virtual TLine *DrawLineNDC(Double_t x1, Double_t y1,Double_t x2, Double_t y2);
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   Double_t GetX1() const {return fX1;}
   Double_t GetX2() const {return fX2;}
   Double_t GetY1() const {return fY1;}
   Double_t GetY2() const {return fY2;}
   Bool_t IsHorizontal();
   Bool_t IsVertical();
   virtual void ls(Option_t *option="") const;
   virtual void Paint(Option_t *option="");
   virtual void PaintLine(Double_t x1, Double_t y1,Double_t x2, Double_t y2);
   virtual void PaintLineNDC(Double_t u1, Double_t v1,Double_t u2, Double_t v2);
   virtual void Print(Option_t *option="") const;
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   void SetHorizontal(Bool_t set = kTRUE); // *TOGGLE* *GETTER=IsHorizontal
   void SetVertical(Bool_t set = kTRUE); // *TOGGLE* *GETTER=IsVertical
   virtual void SetX1(Double_t x1) {fX1=x1;}
   virtual void SetX2(Double_t x2) {fX2=x2;}
   virtual void SetY1(Double_t y1) {fY1=y1;}
   virtual void SetY2(Double_t y2) {fY2=y2;}

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TLine::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TLine::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLine.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 78; } //A line segment
};
# 15 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPaveLabel.h" 1
// @(#)root/graf:$Id: TPaveLabel.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   17/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TPaveLabel                                                           //
//                                                                      //
// PaveLabel  A Pave with a label.                                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPave.h" 1
// @(#)root/graf:$Id: TPave.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   16/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TPave                                                                //
//                                                                      //
// Pave class.                                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBox.h" 1
// @(#)root/graf:$Id: TBox.h 36489 2010-11-03 08:33:25Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TBox                                                                 //
//                                                                      //
// Box class.                                                           //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 34 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBox.h"
class TBox : public TObject, public TAttLine, public TAttFill {

private:
   TObject *fTip; //!tool tip associated with box

protected:
   Double_t fX1; //X of 1st point
   Double_t fY1; //Y of 1st point
   Double_t fX2; //X of 2nd point
   Double_t fY2; //Y of 2nd point
   Bool_t fResizing; //!True if box is being resized

public:
   //----- Private bits, clients can only test but not change them
   enum {
      kCannotMove = (1ULL << (12)) //if set the box cannot be moved/resized
   };
   TBox();
   TBox(Double_t x1, Double_t y1,Double_t x2, Double_t y2);
   TBox(const TBox &box);
   TBox& operator=(const TBox&);
   virtual ~TBox();
   void Copy(TObject &box) const;
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual void Draw(Option_t *option="");
   virtual TBox *DrawBox(Double_t x1, Double_t y1, Double_t x2, Double_t y2);
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   Bool_t IsBeingResized() const { return fResizing; }
   Double_t GetX1() const { return fX1; }
   Double_t GetX2() const { return fX2; }
   Double_t GetY1() const { return fY1; }
   Double_t GetY2() const { return fY2; }
   virtual void HideToolTip(Int_t event);
   virtual Int_t IsInside(Double_t x, Double_t y) const;
   virtual void ls(Option_t *option="") const;
   virtual void Paint(Option_t *option="");
   virtual void PaintBox(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Option_t *option="");
   virtual void Print(Option_t *option="") const;
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetX1(Double_t x1) {fX1=x1;}
   virtual void SetX2(Double_t x2) {fX2=x2;}
   virtual void SetY1(Double_t y1) {fY1=y1;}
   virtual void SetY2(Double_t y2) {fY2=y2;}
   virtual void SetToolTipText(const char *text, Long_t delayms = 1000);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TBox::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TBox::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBox.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 79; } //Box class
};
# 26 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPave.h" 2





class TPave : public TBox {

protected:
   Double_t fX1NDC; //X1 point in NDC coordinates
   Double_t fY1NDC; //Y1 point in NDC coordinates
   Double_t fX2NDC; //X2 point in NDC coordinates
   Double_t fY2NDC; //Y2 point in NDC coordinates
   Int_t fBorderSize; //window box bordersize in pixels
   Int_t fInit; //(=0 if transformation to NDC not yet done)
   Int_t fShadowColor; //Color of the pave's shadow
   Double_t fCornerRadius; //Corner radius in case of option arc
   TString fOption; //Pave style
   TString fName; //Pave name

public:
   // TPave status bits
   enum {
      kNameIsAction = (1ULL << (11)) // double clicking on TPave will execute action
   };

   TPave();
   TPave(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2,
         Int_t bordersize=4 ,Option_t *option="br");
   TPave(const TPave &pave);
   virtual ~TPave();
   void Copy(TObject &pave) const;
   virtual void ConvertNDCtoPad();
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual void Draw(Option_t *option="");
   virtual void DrawPave(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2,
                          Int_t bordersize=4 ,Option_t *option="br");
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   Int_t GetBorderSize() const { return fBorderSize;}
   Double_t GetCornerRadius() const {return fCornerRadius;}
   Option_t *GetName() const {return fName.Data();}
   Option_t *GetOption() const {return fOption.Data();}
   Int_t GetShadowColor() const {return fShadowColor;}
   Double_t GetX1NDC() const {return fX1NDC;}
   Double_t GetX2NDC() const {return fX2NDC;}
   Double_t GetY1NDC() const {return fY1NDC;}
   Double_t GetY2NDC() const {return fY2NDC;}
   virtual ULong_t Hash() const { return fName.Hash(); }
   virtual Bool_t IsSortable() const { return kTRUE; }
   virtual void ls(Option_t *option="") const;
   virtual void Paint(Option_t *option="");
   virtual void PaintPave(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2,
                           Int_t bordersize=4 ,Option_t *option="br");
   virtual void PaintPaveArc(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2,
                              Int_t bordersize=4 ,Option_t *option="br");
   virtual void Print(Option_t *option="") const;
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetBorderSize(Int_t bordersize=4) {fBorderSize = bordersize;} // *MENU*
   virtual void SetCornerRadius(Double_t rad = 0.2) {fCornerRadius = rad;} // *MENU*
   virtual void SetName(const char *name="") {fName = name;} // *MENU*
   virtual void SetOption(Option_t *option="br") {fOption = option;}
   virtual void SetShadowColor(Int_t color) {fShadowColor=color;} // *MENU*
   virtual void SetX1NDC(Double_t x1) {fX1NDC=x1;}
   virtual void SetX2NDC(Double_t x2) {fX2NDC=x2;}
   virtual void SetY1NDC(Double_t y1) {fY1NDC=y1;}
   virtual void SetY2NDC(Double_t y2) {fY2NDC=y2;}

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TPave::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TPave::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPave.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 92; } //Pave. A box with shadowing
};
# 26 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPaveLabel.h" 2






class TPaveLabel : public TPave, public TAttText {

protected:
   TString fLabel; //Label written at the center of Pave

public:
   TPaveLabel();
   TPaveLabel(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2, const char *label, Option_t *option="br");
   TPaveLabel(const TPaveLabel &pavelabel);
   virtual ~TPaveLabel();

   void Copy(TObject &pavelabel) const;
   virtual void Draw(Option_t *option="");
   virtual void DrawPaveLabel(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2,
                      const char *label, Option_t *option="");
   const char *GetLabel() const {return fLabel.Data();}
   const char *GetTitle() const {return fLabel.Data();}
   virtual void Paint(Option_t *option="");
   virtual void PaintPaveLabel(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2,
                      const char *label, Option_t *option="");
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetLabel(const char *label) {fLabel = label;} // *MENU*

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TPaveLabel::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TPaveLabel::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPaveLabel.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 55; } //PaveLabel. A Pave with a label
};
# 16 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGClient.h" 1
// @(#)root/gui:$Id: TGClient.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Fons Rademakers   27/12/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGClient                                                             //
//                                                                      //
// Window client. In client server windowing systems, like X11 this     //
// class is used to make the initial connection to the window server.   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 39 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGClient.h"
class TList;
class THashList;
class TGWindow;
class TGResourcePool;
class TGPicturePool;
class TGPicture;
class TGGCPool;
class TGGC;
class TGFontPool;
class TGFont;
class TGMimeTypes;
class TGUnknownWindowHandler;
class TGIdleHandler;


class TGClient : public TObject, public TQObject {

friend class TGCocoa;

protected:
   Pixel_t fBackColor; // default background color
   Pixel_t fForeColor; // default foreground color
   Pixel_t fHilite; // default hilite color
   Pixel_t fShadow; // default shadow color
   Pixel_t fSelBackColor; // default selection background color
   Pixel_t fSelForeColor; // default selection foreground color
   Pixel_t fWhite; // white color index
   Pixel_t fBlack; // black color index
   TGWindow *fDefaultRoot; // default root window (base window of display)
   TGWindow *fRoot; // current root window (changing root window allows embedding)
   Int_t fXfd; // file descriptor of connection to server
   TGResourcePool *fResourcePool; // global GUI resource pool
   TGGCPool *fGCPool; // graphics context pool
   TGFontPool *fFontPool; // font pool
   TGPicturePool *fPicturePool; // pixmap pool
   TGMimeTypes *fMimeTypeList; // mimetype list
   Colormap_t fDefaultColormap; // default colormap
   Bool_t fGlobalNeedRedraw; // true if at least one window needs to be redrawn
   Bool_t fForceRedraw; // redraw widgets as soon as possible
   THashList *fWlist; // list of frames
   TList *fPlist; // list of popup windows used in HandleMaskEvent()
   TList *fUWHandlers; // list of event handlers for unknown windows
   TList *fIdleHandlers; // list of idle handlers
   EGEventType fWaitForEvent; // event to wait for
   Window_t fWaitForWindow; // window in which to wait for event
   UInt_t fStyle; // GUI style (modern or classic)

   TGClient(const TGClient&); // not implemented
   TGClient& operator=(const TGClient&); // not implemented

   Bool_t ProcessOneEvent();
   Bool_t ProcessIdleEvent();
   Bool_t DoRedraw();

public:
   TGClient(const char *dpyName = 0);
   virtual ~TGClient();

   const TGWindow *GetRoot() const;
   const TGWindow *GetDefaultRoot() const;
   void SetRoot(TGWindow *root = 0);
   TGWindow *GetWindowById(Window_t sw) const;
   TGWindow *GetWindowByName(const char *name) const;

   UInt_t GetDisplayWidth() const;
   UInt_t GetDisplayHeight() const;

   Bool_t IsEditable() const { return fRoot != fDefaultRoot; }
   Bool_t IsEditDisabled() const;
   void SetEditDisabled(Bool_t on = kTRUE);

   FontStruct_t GetFontByName(const char *name, Bool_t fixedDefault = kTRUE) const;
   Bool_t GetColorByName(const char *name, Pixel_t &pixel) const;
   Pixel_t GetHilite(Pixel_t base_color) const;
   Pixel_t GetShadow(Pixel_t base_color) const;
   void FreeColor(Pixel_t color) const;
   void ForceRedraw() { fForceRedraw = kTRUE; }
   void NeedRedraw(TGWindow *w, Bool_t force = kFALSE);
   void CancelRedraw(TGWindow *w);
   void RegisterWindow(TGWindow *w);
   void UnregisterWindow(TGWindow *w);
   void RegisterPopup(TGWindow *w);
   void UnregisterPopup(TGWindow *w);
   void AddUnknownWindowHandler(TGUnknownWindowHandler *h);
   void RemoveUnknownWindowHandler(TGUnknownWindowHandler *h);
   void AddIdleHandler(TGIdleHandler *h);
   void RemoveIdleHandler(TGIdleHandler *h);
   Bool_t HandleInput();
   void ProcessLine(TString cmd, Long_t msg, Long_t parm1, Long_t parm2);
   void WaitFor(TGWindow *w);
   void WaitForUnmap(TGWindow *w);
   void ResetWaitFor(TGWindow *w);
   EGEventType GetWaitForEvent() const { return fWaitForEvent;}
   Window_t GetWaitForWindow() const { return fWaitForWindow; }
   void SetWaitForWindow(Window_t wid) {fWaitForWindow = wid;}
   Bool_t ProcessEventsFor(TGWindow *w);

   Bool_t HandleEvent(Event_t *event);
   Bool_t HandleMaskEvent(Event_t *event, Window_t wid);
   void RegisteredWindow(Window_t w); //*SIGNAL*
   void ProcessedEvent(Event_t *event, Window_t wid); //*SIGNAL*

   const TGResourcePool *GetResourcePool() const { return fResourcePool; }

   TGPicturePool *GetPicturePool() const { return fPicturePool; }
   const TGPicture *GetPicture(const char *name);
   const TGPicture *GetPicture(const char *name, UInt_t new_width, UInt_t new_height);
   void FreePicture(const TGPicture *pic);

   TGGCPool *GetGCPool() const { return fGCPool; }
   TGGC *GetGC(GCValues_t *values, Bool_t rw = kFALSE);
   void FreeGC(const TGGC *gc);
   void FreeGC(GContext_t gc);

   TGFontPool *GetFontPool() const { return fFontPool; }
   TGFont *GetFont(const char *font, Bool_t fixedDefault = kTRUE);
   TGFont *GetFont(const TGFont *font);
   void FreeFont(const TGFont *font);

   UInt_t GetStyle() const { return fStyle; }
   void SetStyle(UInt_t newstyle) { fStyle = newstyle; }
   void SetStyle(const char *style);

   Colormap_t GetDefaultColormap() const { return fDefaultColormap; }
   TGMimeTypes *GetMimeTypeList() const { return fMimeTypeList; }

   THashList *GetListOfWindows() const { return fWlist; }
   TList *GetListOfPopups() const { return fPlist; }

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TGClient::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TGClient::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGClient.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 168; } // Class making connection to display server
};

extern TGClient *gClient;
# 17 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TStyle.h" 1
// @(#)root/base:$Id: TStyle.h 38506 2011-03-18 14:08:49Z couet $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TStyle                                                               //
//                                                                      //
// A collection of all graphics attributes.                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 47 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TStyle.h"
class TBrowser;

class TStyle : public TNamed, public TAttLine, public TAttFill, public TAttMarker, public TAttText {

private:
   TAttAxis fXaxis; //X axis attributes
   TAttAxis fYaxis; //Y axis attributes
   TAttAxis fZaxis; //Z axis attributes
   Float_t fBarWidth; //width of bar for graphs
   Float_t fBarOffset; //offset of bar for graphs
   Int_t fColorModelPS; //PostScript color model: 0 = RGB, 1 = CMYK
   Int_t fDrawBorder; //flag to draw border(=1) or not (0)
   Int_t fOptLogx; //=1 if log scale in X
   Int_t fOptLogy; //=1 if log scale in y
   Int_t fOptLogz; //=1 if log scale in z
   Int_t fOptDate; //=1 if date option is selected
   Int_t fOptStat; //=1 if option Stat is selected
   Int_t fOptTitle; //=1 if option Title is selected
   Int_t fOptFile; //=1 if option File is selected
   Int_t fOptFit; //=1 if option Fit is selected
   Int_t fShowEventStatus; //Show event status panel
   Int_t fShowEditor; //Show pad editor
   Int_t fShowToolBar; //Show toolbar

   Int_t fNumberContours; //default number of contours for 2-d plots
   TAttText fAttDate; //canvas date attribute
   Float_t fDateX; //X position of the date in the canvas (in NDC)
   Float_t fDateY; //Y position of the date in the canvas (in NDC)
   Float_t fEndErrorSize; //Size of lines at the end of error bars
   Float_t fErrorX; //per cent of bin width for errors along X
   Color_t fFuncColor; //function color
   Style_t fFuncStyle; //function style
   Width_t fFuncWidth; //function line width
   Color_t fGridColor; //grid line color (if 0 use axis line color)
   Style_t fGridStyle; //grid line style
   Width_t fGridWidth; //grid line width
   Width_t fLegendBorderSize; //legend box border size
   Color_t fLegendFillColor; //legend fill color
   Style_t fLegendFont; //legend font style
   Int_t fHatchesLineWidth; //hatches line width for hatch styles > 3100
   Double_t fHatchesSpacing; //hatches spacing for hatch styles > 3100
   Color_t fFrameFillColor; //pad frame fill color
   Color_t fFrameLineColor; //pad frame line color
   Style_t fFrameFillStyle; //pad frame fill style
   Style_t fFrameLineStyle; //pad frame line style
   Width_t fFrameLineWidth; //pad frame line width
   Width_t fFrameBorderSize; //pad frame border size
   Int_t fFrameBorderMode; //pad frame border mode
   Color_t fHistFillColor; //histogram fill color
   Color_t fHistLineColor; //histogram line color
   Style_t fHistFillStyle; //histogram fill style
   Style_t fHistLineStyle; //histogram line style
   Width_t fHistLineWidth; //histogram line width
   Bool_t fHistMinimumZero; //true if default minimum is 0, false if minimum is automatic
   Double_t fHistTopMargin; //margin between histogram's top and pad's top
   Bool_t fCanvasPreferGL; //if true, rendering in canvas is with GL
   Color_t fCanvasColor; //canvas color
   Width_t fCanvasBorderSize; //canvas border size
   Int_t fCanvasBorderMode; //canvas border mode
   Int_t fCanvasDefH; //default canvas height
   Int_t fCanvasDefW; //default canvas width
   Int_t fCanvasDefX; //default canvas top X position
   Int_t fCanvasDefY; //default canvas top Y position
   Color_t fPadColor; //pad color
   Width_t fPadBorderSize; //pad border size
   Int_t fPadBorderMode; //pad border mode
   Float_t fPadBottomMargin; //pad bottom margin
   Float_t fPadTopMargin; //pad top margin
   Float_t fPadLeftMargin; //pad left margin
   Float_t fPadRightMargin; //pad right margin
   Bool_t fPadGridX; //true to get the grid along X
   Bool_t fPadGridY; //true to get the grid along Y
   Int_t fPadTickX; //=1 to set special pad ticks along X
   Int_t fPadTickY; //=1 to set special pad ticks along Y
   Float_t fPaperSizeX; //PostScript paper size along X
   Float_t fPaperSizeY; //PostScript paper size along Y
   Float_t fScreenFactor; //Multiplication factor for canvas size and position
   Color_t fStatColor; //stat fill area color
   Color_t fStatTextColor; //stat text color
   Width_t fStatBorderSize; //border size of Stats PaveLabel
   Style_t fStatFont; //font style of Stats PaveLabel
   Float_t fStatFontSize; //font size in pixels for fonts with precision type 3
   Style_t fStatStyle; //fill area style of Stats PaveLabel
   TString fStatFormat; //Printing format for stats
   Float_t fStatX; //X position of top right corner of stat box
   Float_t fStatY; //Y position of top right corner of stat box
   Float_t fStatW; //width of stat box
   Float_t fStatH; //height of stat box
   Bool_t fStripDecimals; //Strip decimals in axis labels
   Int_t fTitleAlign; //title box alignment
   Color_t fTitleColor; //title fill area color
   Color_t fTitleTextColor; //title text color
   Width_t fTitleBorderSize; //border size of Title PavelLabel
   Style_t fTitleFont; //font style of Title PaveLabel
   Float_t fTitleFontSize; //font size in pixels for fonts with precision type 3
   Style_t fTitleStyle; //fill area style of title PaveLabel
   Float_t fTitleX; //X position of top left corner of title box
   Float_t fTitleY; //Y position of top left corner of title box
   Float_t fTitleW; //width of title box
   Float_t fTitleH; //height of title box
   Float_t fLegoInnerR; //Inner radius for cylindrical legos
   TString fLineStyle[30]; //String describing line style i (for postScript)
   TString fHeaderPS; //User defined additional Postscript header
   TString fTitlePS; //User defined Postscript file title
   TString fFitFormat; //Printing format for fit parameters
   TString fPaintTextFormat; //Printing format for TH2::PaintText
   Float_t fLineScalePS; //Line scale factor when drawing lines on Postscript
   Double_t fTimeOffset; //Time offset to the beginning of an axis
   Bool_t fIsReading; //!Set to FALSE when userclass::UseCurrentStyle is called by the style manager
public:
   enum EPaperSize { kA4, kUSLetter };

   TStyle();
   TStyle(const char *name, const char *title);
   TStyle(const TStyle &style);
   virtual ~TStyle();
   Int_t AxisChoice(Option_t *axis) const;
   virtual void Browse(TBrowser *b);
   static void BuildStyles();
   virtual void Copy(TObject &style) const;
   virtual void cd();

   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   Int_t GetNdivisions(Option_t *axis="X") const;
   TAttText *GetAttDate() {return &fAttDate;}
   Color_t GetAxisColor(Option_t *axis="X") const;
   Color_t GetLabelColor(Option_t *axis="X") const;
   Style_t GetLabelFont(Option_t *axis="X") const;
   Float_t GetLabelOffset(Option_t *axis="X") const;
   Float_t GetLabelSize(Option_t *axis="X") const;
   Color_t GetTitleColor(Option_t *axis="X") const; //return axis title color of pad title color
   Style_t GetTitleFont(Option_t *axis="X") const; //return axis title font of pad title font
   Float_t GetTitleOffset(Option_t *axis="X") const; //return axis title offset
   Float_t GetTitleSize(Option_t *axis="X") const; //return axis title size
   Float_t GetTickLength(Option_t *axis="X") const;

   Float_t GetBarOffset() const {return fBarOffset;}
   Float_t GetBarWidth() const {return fBarWidth;}
   Int_t GetDrawBorder() const {return fDrawBorder;}
   Float_t GetEndErrorSize() const {return fEndErrorSize;}
   Float_t GetErrorX() const {return fErrorX;}
   Bool_t GetCanvasPreferGL() const {return fCanvasPreferGL;}
   Color_t GetCanvasColor() const {return fCanvasColor;}
   Width_t GetCanvasBorderSize() const {return fCanvasBorderSize;}
   Int_t GetCanvasBorderMode() const {return fCanvasBorderMode;}
   Int_t GetCanvasDefH() const {return fCanvasDefH;}
   Int_t GetCanvasDefW() const {return fCanvasDefW;}
   Int_t GetCanvasDefX() const {return fCanvasDefX;}
   Int_t GetCanvasDefY() const {return fCanvasDefY;}
   Int_t GetColorPalette(Int_t i) const;
   Int_t GetColorModelPS() const {return fColorModelPS;}
   Float_t GetDateX() const {return fDateX;}
   Float_t GetDateY() const {return fDateY;}
   const char *GetFitFormat() const {return fFitFormat.Data();}
   Int_t GetHatchesLineWidth() const {return fHatchesLineWidth;}
   Double_t GetHatchesSpacing() const {return fHatchesSpacing;}
   Width_t GetLegendBorderSize() const {return fLegendBorderSize;}
   Color_t GetLegendFillColor() const {return fLegendFillColor;}
   Style_t GetLegendFont() const {return fLegendFont;}
   Int_t GetNumberOfColors() const;
   Color_t GetPadColor() const {return fPadColor;}
   Width_t GetPadBorderSize() const {return fPadBorderSize;}
   Int_t GetPadBorderMode() const {return fPadBorderMode;}
   Float_t GetPadBottomMargin() const {return fPadBottomMargin;}
   Float_t GetPadTopMargin() const {return fPadTopMargin;}
   Float_t GetPadLeftMargin() const {return fPadLeftMargin;}
   Float_t GetPadRightMargin() const {return fPadRightMargin;}
   Bool_t GetPadGridX() const {return fPadGridX;}
   Bool_t GetPadGridY() const {return fPadGridY;}
   Int_t GetPadTickX() const {return fPadTickX;}
   Int_t GetPadTickY() const {return fPadTickY;}
   Color_t GetFuncColor() const {return fFuncColor;}
   Style_t GetFuncStyle() const {return fFuncStyle;}
   Width_t GetFuncWidth() const {return fFuncWidth;}
   Color_t GetGridColor() const {return fGridColor;}
   Style_t GetGridStyle() const {return fGridStyle;}
   Width_t GetGridWidth() const {return fGridWidth;}
   Color_t GetFrameFillColor() const {return fFrameFillColor;}
   Color_t GetFrameLineColor() const {return fFrameLineColor;}
   Style_t GetFrameFillStyle() const {return fFrameFillStyle;}
   Style_t GetFrameLineStyle() const {return fFrameLineStyle;}
   Width_t GetFrameLineWidth() const {return fFrameLineWidth;}
   Width_t GetFrameBorderSize() const {return fFrameBorderSize;}
   Int_t GetFrameBorderMode() const {return fFrameBorderMode;}
   Color_t GetHistFillColor() const {return fHistFillColor;}
   Color_t GetHistLineColor() const {return fHistLineColor;}
   Style_t GetHistFillStyle() const {return fHistFillStyle;}
   Style_t GetHistLineStyle() const {return fHistLineStyle;}
   Width_t GetHistLineWidth() const {return fHistLineWidth;}
   Bool_t GetHistMinimumZero() const {return fHistMinimumZero;}
   Double_t GetHistTopMargin() const {return fHistTopMargin;}
   Float_t GetLegoInnerR() const {return fLegoInnerR;}
   Int_t GetNumberContours() const {return fNumberContours;}
   Int_t GetOptDate() const {return fOptDate;}
   Int_t GetOptFile() const {return fOptFile;}
   Int_t GetOptFit() const {return fOptFit;}
   Int_t GetOptStat() const {return fOptStat;}
   Int_t GetOptTitle() const {return fOptTitle;}
   Int_t GetOptLogx() const {return fOptLogx;}
   Int_t GetOptLogy() const {return fOptLogy;}
   Int_t GetOptLogz() const {return fOptLogz;}
   const char *GetPaintTextFormat() const {return fPaintTextFormat.Data();}
   void GetPaperSize(Float_t &xsize, Float_t &ysize) const;
   Int_t GetShowEventStatus() const {return fShowEventStatus;}
   Int_t GetShowEditor() const {return fShowEditor;}
   Int_t GetShowToolBar() const {return fShowToolBar;}

   Float_t GetScreenFactor() const {return fScreenFactor;}
   Color_t GetStatColor() const {return fStatColor;}
   Color_t GetStatTextColor() const {return fStatTextColor;}
   Width_t GetStatBorderSize() const {return fStatBorderSize;}
   Style_t GetStatFont() const {return fStatFont;}
   Float_t GetStatFontSize() const {return fStatFontSize;}
   Style_t GetStatStyle() const {return fStatStyle;}
   const char *GetStatFormat() const {return fStatFormat.Data();}
   Float_t GetStatX() const {return fStatX;}
   Float_t GetStatY() const {return fStatY;}
   Float_t GetStatW() const {return fStatW;}
   Float_t GetStatH() const {return fStatH;}
   Int_t GetStripDecimals() const {return fStripDecimals;}
   Double_t GetTimeOffset() const {return fTimeOffset;} //return axis time offset
   Int_t GetTitleAlign() {return fTitleAlign;} // return the histogram title TPaveLabel alignment
   Color_t GetTitleFillColor() const {return fTitleColor;} //return histogram title fill area color
   Color_t GetTitleTextColor() const {return fTitleTextColor;} //return histogram title text color
   Style_t GetTitleStyle() const {return fTitleStyle;}
   Float_t GetTitleFontSize() const {return fTitleFontSize;} //return histogram title font size
   Width_t GetTitleBorderSize() const {return fTitleBorderSize;} //return border size of histogram title TPaveLabel
   Float_t GetTitleXOffset() const {return GetTitleOffset("X");} //return X axis title offset
   Float_t GetTitleXSize() const {return GetTitleSize("X");} //return X axis title size
   Float_t GetTitleYOffset() const {return GetTitleOffset("Y");} //return Y axis title offset
   Float_t GetTitleYSize() const {return GetTitleSize("Y");} //return Y axis title size
   Float_t GetTitleX() const {return fTitleX;} //return left X position of histogram title TPavelabel
   Float_t GetTitleY() const {return fTitleY;} //return left bottom position of histogram title TPavelabel
   Float_t GetTitleW() const {return fTitleW;} //return width of histogram title TPaveLabel
   Float_t GetTitleH() const {return fTitleH;} //return height of histogram title TPavelabel
   const char *GetHeaderPS() const {return fHeaderPS.Data();}
   const char *GetTitlePS() const {return fTitlePS.Data();}
   const char *GetLineStyleString(Int_t i=1) const;
   Float_t GetLineScalePS() const {return fLineScalePS;}
   Bool_t IsReading() const {return fIsReading;}
   virtual void Paint(Option_t *option="");
   virtual void Reset(Option_t *option="");

   void SetColorModelPS(Int_t c=0);
   void SetFitFormat(const char *format="5.4g") {fFitFormat = format;}
   void SetHeaderPS(const char *header);
   void SetHatchesLineWidth(Int_t l) {fHatchesLineWidth = l;}
   void SetHatchesSpacing(Double_t h) {fHatchesSpacing = TMath::Max(0.1,h);}
   void SetTitlePS(const char *pstitle);
   void SetLineScalePS(Float_t scale=3) {fLineScalePS=scale;}
   void SetLineStyleString(Int_t i, const char *text);
   void SetNdivisions(Int_t n=510, Option_t *axis="X");
   void SetAxisColor(Color_t color=1, Option_t *axis="X");
   void SetLabelColor(Color_t color=1, Option_t *axis="X");
   void SetLabelFont(Style_t font=62, Option_t *axis="X");
   void SetLabelOffset(Float_t offset=0.005, Option_t *axis="X");
   void SetLabelSize(Float_t size=0.04, Option_t *axis="X");
   void SetLegoInnerR(Float_t rad=0.5) {fLegoInnerR = rad;}
   void SetScreenFactor(Float_t factor=1) {fScreenFactor = factor;}
   void SetTickLength(Float_t length=0.03, Option_t *axis="X");
   void SetTitleColor(Color_t color=1, Option_t *axis="X"); //set axis title color or pad title color
   void SetTitleFont(Style_t font=62, Option_t *axis="X"); //set axis title font or pad title font
   void SetTitleOffset(Float_t offset=1, Option_t *axis="X"); //set axis title offset
   void SetTitleSize(Float_t size=0.02, Option_t *axis="X"); //set axis title size or pad title size
   void SetNumberContours(Int_t number=20);
   void SetOptDate(Int_t datefl=1);
   void SetOptFile(Int_t file=1) {fOptFile = file;}
   void SetOptFit(Int_t fit=1);
   void SetOptLogx(Int_t logx=1) {fOptLogx = logx;}
   void SetOptLogy(Int_t logy=1) {fOptLogy = logy;}
   void SetOptLogz(Int_t logz=1) {fOptLogz = logz;}
   void SetOptStat(Int_t stat=1);
   void SetOptStat(Option_t *stat);
   void SetOptTitle(Int_t tit=1) {fOptTitle = tit;}
   void SetBarOffset(Float_t baroff=0.5) {fBarOffset = baroff;}
   void SetBarWidth(Float_t barwidth=0.5) {fBarWidth = barwidth;}
   void SetDateX(Float_t x=0.01) {fDateX = x;}
   void SetDateY(Float_t y=0.01) {fDateY = y;}
   void SetEndErrorSize(Float_t np=2);
   void SetErrorX(Float_t errorx=0.5) {fErrorX = errorx;}
   void SetCanvasPreferGL(Bool_t prefer = kTRUE) {fCanvasPreferGL=prefer;}
   void SetDrawBorder(Int_t drawborder=1) {fDrawBorder = drawborder;}
   void SetCanvasColor(Color_t color=19) {fCanvasColor = color;}
   void SetCanvasBorderSize(Width_t size=1) {fCanvasBorderSize = size;}
   void SetCanvasBorderMode(Int_t mode=1) {fCanvasBorderMode = mode;}
   void SetCanvasDefH(Int_t h=500) {fCanvasDefH = h;}
   void SetCanvasDefW(Int_t w=700) {fCanvasDefW = w;}
   void SetCanvasDefX(Int_t topx=10) {fCanvasDefX = topx;}
   void SetCanvasDefY(Int_t topy=10) {fCanvasDefY = topy;}
   void SetLegendBorderSize(Width_t size=4) {fLegendBorderSize = size;}
   void SetLegendFillColor(Color_t color=0) {fLegendFillColor = color;}
   void SetLegendFont(Style_t font=62) {fLegendFont = font;}
   void SetPadColor(Color_t color=19) {fPadColor = color;}
   void SetPadBorderSize(Width_t size=1) {fPadBorderSize = size;}
   void SetPadBorderMode(Int_t mode=1) {fPadBorderMode = mode;}
   void SetPadBottomMargin(Float_t margin=0.1) {fPadBottomMargin=margin;}
   void SetPadTopMargin(Float_t margin=0.1) {fPadTopMargin=margin;}
   void SetPadLeftMargin(Float_t margin=0.1) {fPadLeftMargin=margin;}
   void SetPadRightMargin(Float_t margin=0.1) {fPadRightMargin=margin;}
   void SetPadGridX(Bool_t gridx) {fPadGridX = gridx;}
   void SetPadGridY(Bool_t gridy) {fPadGridY = gridy;}
   void SetPadTickX(Int_t tickx) {fPadTickX = tickx;}
   void SetPadTickY(Int_t ticky) {fPadTickY = ticky;}
   void SetFuncStyle(Style_t style=1) {fFuncStyle = style;}
   void SetFuncColor(Color_t color=1) {fFuncColor = color;}
   void SetFuncWidth(Width_t width=4) {fFuncWidth = width;}
   void SetGridStyle(Style_t style=3) {fGridStyle = style;}
   void SetGridColor(Color_t color=0) {fGridColor = color;}
   void SetGridWidth(Width_t width=1) {fGridWidth = width;}
   void SetFrameFillColor(Color_t color=1) {fFrameFillColor = color;}
   void SetFrameLineColor(Color_t color=1) {fFrameLineColor = color;}
   void SetFrameFillStyle(Style_t styl=0) {fFrameFillStyle = styl;}
   void SetFrameLineStyle(Style_t styl=0) {fFrameLineStyle = styl;}
   void SetFrameLineWidth(Width_t width=1) {fFrameLineWidth = width;}
   void SetFrameBorderSize(Width_t size=1) {fFrameBorderSize = size;}
   void SetFrameBorderMode(Int_t mode=1) {fFrameBorderMode = mode;}
   void SetHistFillColor(Color_t color=1) {fHistFillColor = color;}
   void SetHistLineColor(Color_t color=1) {fHistLineColor = color;}
   void SetHistFillStyle(Style_t styl=0) {fHistFillStyle = styl;}
   void SetHistLineStyle(Style_t styl=0) {fHistLineStyle = styl;}
   void SetHistLineWidth(Width_t width=1) {fHistLineWidth = width;}
   void SetHistMinimumZero(Bool_t zero=kTRUE);
   void SetHistTopMargin(Double_t hmax=0.05) {fHistTopMargin = hmax;}
   void SetPaintTextFormat(const char *format="g") {fPaintTextFormat = format;}
   void SetPaperSize(EPaperSize size);
   void SetPaperSize(Float_t xsize=20, Float_t ysize=26);
   void SetStatColor(Int_t color=19) {fStatColor=color;}
   void SetStatTextColor(Int_t color=1) {fStatTextColor=color;}
   void SetStatStyle(Style_t style=1001) {fStatStyle=style;}
   void SetStatBorderSize(Width_t size=2) {fStatBorderSize=size;}
   void SetStatFont(Style_t font=62) {fStatFont=font;}
   void SetStatFontSize(Float_t size=0) {fStatFontSize=size;}
   void SetStatFormat(const char *format="6.4g") {fStatFormat = format;}
   void SetStatX(Float_t x=0) {fStatX=x;}
   void SetStatY(Float_t y=0) {fStatY=y;}
   void SetStatW(Float_t w=0.19) {fStatW=w;}
   void SetStatH(Float_t h=0.1) {fStatH=h;}
   void SetStripDecimals(Bool_t strip=kTRUE);
   void SetTimeOffset(Double_t toffset);
   void SetTitleAlign(Int_t a=13) {fTitleAlign=a;}
   void SetTitleFillColor(Color_t color=1) {fTitleColor=color;}
   void SetTitleTextColor(Color_t color=1) {fTitleTextColor=color;}
   void SetTitleStyle(Style_t style=1001) {fTitleStyle=style;}
   void SetTitleFontSize(Float_t size=0) {fTitleFontSize=size;}
   void SetTitleBorderSize(Width_t size=2) {fTitleBorderSize=size;}
   void SetTitleXOffset(Float_t offset=1) {SetTitleOffset(offset,"X");}
   void SetTitleXSize(Float_t size=0.02) {SetTitleSize(size,"X");}
   void SetTitleYOffset(Float_t offset=1) {SetTitleOffset(offset,"Y");}
   void SetTitleYSize(Float_t size=0.02) {SetTitleSize(size,"Y");}
   void SetTitleX(Float_t x=0) {fTitleX=x;}
   void SetTitleY(Float_t y=0.985) {fTitleY=y;}
   void SetTitleW(Float_t w=0) {fTitleW=w;}
   void SetTitleH(Float_t h=0) {fTitleH=h;}
   void ToggleEventStatus() { fShowEventStatus = fShowEventStatus ? 0 : 1; }
   void ToggleEditor() { fShowEditor = fShowEditor ? 0 : 1; }
   void ToggleToolBar() { fShowToolBar = fShowToolBar ? 0 : 1; }
   void SetIsReading(Bool_t reading=kTRUE);
   void SetPalette(Int_t ncolors=0, Int_t *colors=0);
   void SavePrimitive(ostream &out, Option_t * = "");
   void SaveSource(const char *filename, Option_t *option=0);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 14; } static void Dictionary(); virtual TClass *IsA() const { return TStyle::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TStyle::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TStyle.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 408; }; //A collection of all graphics attributes
};


extern TStyle *gStyle;
# 18 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h" 1
// @(#)root/base:$Id: TSystem.h 42099 2011-11-17 19:16:32Z rdm $
// Author: Fons Rademakers   15/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TSystem                                                              //
//                                                                      //
// Abstract base class defining a generic interface to the underlying   //
// Operating System.                                                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 41 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h"
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TInetAddress.h" 1
// @(#)root/base:$Id: TInetAddress.h 41637 2011-10-28 15:34:35Z rdm $
// Author: Fons Rademakers   16/12/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TInetAddress                                                         //
//                                                                      //
// This class represents an Internet Protocol (IP) address.             //
// Objects of this class can not be created directly, but only via      //
// the TSystem GetHostByName(), GetSockName(), and GetPeerName()        //
// members and via members of the TServerSocket and TSocket classes.    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 34 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TInetAddress.h"
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/vector" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_vector" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <vector.dll>
#pragma include_noerr <vectorbool.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/vector

#pragma ifndef PREC_STL_VECTOR
#pragma define PREC_STL_VECTOR
#pragma link off global PREC_STL_VECTOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from ANSI/ISO C++ 1997/Nov draft 
// Got some ideas from Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <iterator.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/iterator

#pragma ifndef PREC_STL_ITERATOR
#pragma define PREC_STL_ITERATOR
#pragma link off global PREC_STL_ITERATOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from STL HP implementation 1994
// Imported from STL SGI implementation 1997 
// Imported from ANSI/ISO C++ draft Nov 1997
// Modified by Masaharu Goto
// May need improvement for the latest standard


////////////////////////////////////////////////////////////////////////
// iterator_tag
////////////////////////////////////////////////////////////////////////
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag {};
struct bidirectional_iterator_tag {};
struct random_access_iterator_tag {};

////////////////////////////////////////////////////////////////////////
// iterator template
////////////////////////////////////////////////////////////////////////
template <class T, class Distance> struct input_iterator {};
struct output_iterator {};
template <class T, class Distance> struct forward_iterator {};
template <class T, class Distance> struct bidirectional_iterator {};
template <class T, class Distance> struct random_access_iterator {};

#pragma link off class output_iterator;







////////////////////////////////////////////////////////////////////////
// iterator_category overloaded function
////////////////////////////////////////////////////////////////////////
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const input_iterator<T, Distance>&) {
    return input_iterator_tag();
}

inline output_iterator_tag iterator_category(const output_iterator&) {
    return output_iterator_tag();
}

#pragma link off function iterator_category(const output_iterator&);


template <class T, class Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<T, Distance>&) {
    return forward_iterator_tag();
}

template <class T, class Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<T, Distance>&) {
    return bidirectional_iterator_tag();
}

template <class T, class Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<T, Distance>&) {
    return random_access_iterator_tag();
}

template <class T>
inline random_access_iterator_tag
iterator_category(const T*) {
    return random_access_iterator_tag();
}


// iterator_traits, iterator and reverse_iterator template may not be
// needed for precompiled library interface 

////////////////////////////////////////////////////////////////////////
// iterator_traits
////////////////////////////////////////////////////////////////////////

template <class Iterator>
struct iterator_traits {
  typedef typename Iterator::iterator_category iterator_category;
  typedef typename Iterator::value_type value_type;
  typedef typename Iterator::difference_type difference_type;
  typedef typename Iterator::pointer pointer;
  typedef typename Iterator::reference reference;
};

// template partial specialization, implement in cint5.15.14 1587
template <class T>
struct iterator_traits<T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef T& reference;
};

// incomplete implementation in cint5.15.14 1587, need some fix
// iterator_traits<const int*> is changed as iterator_traits<const int* const>
// or something, but cint5.15.14 can not handle this well
template <class T>
struct iterator_traits<const T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef const T* pointer;
  typedef const T& reference;
};

////////////////////////////////////////////////////////////////////////
// iterator
////////////////////////////////////////////////////////////////////////
template<class Category, class T, class Distance = ptrdiff_t,
         class Pointer = T*, class Reference = T&>
struct iterator {
  typedef T value_type;
  typedef Distance difference_type;
  typedef Pointer pointer;
  typedef Reference reference;
  typedef Category iterator_category;
};


////////////////////////////////////////////////////////////////////////
// reverse_iterator
////////////////////////////////////////////////////////////////////////






template <class Iterator>
class reverse_iterator
# 166 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
{




 public:
# 181 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
   typedef Iterator::pointer pointer;
   typedef Iterator::reference reference;
   typedef ptrdiff_t difference_type;


   reverse_iterator();
   //reverse_iterator(Iterator x);



   Iterator base() const; // explicit
   reference operator*() const;
   pointer operator->() const;
   reverse_iterator& operator++();
   reverse_iterator operator++(int);
   reverse_iterator& operator--();
   reverse_iterator operator--(int);
   reverse_iterator operator+ (difference_type n) const;
   reverse_iterator& operator+=(difference_type n);
   reverse_iterator operator- (difference_type n) const;
   reverse_iterator& operator-=(difference_type n);
   reference operator[](difference_type n) const;
};
# 932 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
// for g++ 3.1,3.2
namespace __gnu_cxx
{
  // This iterator adapter is 'normal' in the sense that it does not
  // change the semantics of any of the operators of its iterator
  // parameter.  Its primary purpose is to convert an iterator that is
  // not a class, e.g. a pointer, into an iterator that is a class.
  // The _Container parameter exists solely so that different containers
  // using this template can instantiate different types, even if the
  // _Iterator parameter is the same.
  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
      : public iterator<typename iterator_traits<_Iterator>::iterator_category,
                        typename iterator_traits<_Iterator>::value_type,
                        typename iterator_traits<_Iterator>::difference_type,
                        typename iterator_traits<_Iterator>::pointer,
                        typename iterator_traits<_Iterator>::reference>
    {
    protected:
      _Iterator _M_current;

    public:
      typedef typename iterator_traits<_Iterator>::difference_type
                    difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

      __normal_iterator() : _M_current(_Iterator()) { }

      explicit
      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

      // Allow iterator to const_iterator conversion
      template<typename _Iter>
      inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
 : _M_current(__i.base()) { }

      // Forward iterator requirements
      reference
      operator*() const { return *_M_current; }

      pointer
      operator->() const { return _M_current; }

      __normal_iterator&
      operator++() { ++_M_current; return *this; }

      __normal_iterator
      operator++(int) { return __normal_iterator(_M_current++); }

      // Bidirectional iterator requirements
      __normal_iterator&
      operator--() { --_M_current; return *this; }

      __normal_iterator
      operator--(int) { return __normal_iterator(_M_current--); }

      // Random access iterator requirements
      reference
      operator[](const difference_type& __n) const
      { return _M_current[__n]; }

      __normal_iterator&
      operator+=(const difference_type& __n)
      { _M_current += __n; return *this; }

      __normal_iterator
      operator+(const difference_type& __n) const
      { return __normal_iterator(_M_current + __n); }

      __normal_iterator&
      operator-=(const difference_type& __n)
      { _M_current -= __n; return *this; }

      __normal_iterator
      operator-(const difference_type& __n) const
      { return __normal_iterator(_M_current - __n); }

      const _Iterator&
      base() const { return _M_current; }
    };

  // Note: In what follows, the left- and right-hand-side iterators are
  // allowed to vary in types (conceptually in cv-qualification) so that
  // comparaison between cv-qualified and non-cv-qualified iterators be
  // valid.  However, the greedy and unfriendly operators in std::rel_ops
  // will make overload resolution ambiguous (when in scope) if we don't
  // provide overloads whose operands are of the same type.  Can someone
  // remind me what generic programming is about? -- Gaby

  // Forward iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  // Random access iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  // _GLIBCPP_RESOLVE_LIB_DEFECTS
  // According to the resolution of DR179 not only the various comparison
  // operators but also operator- must accept mixed iterator/const_iterator
  // parameters.
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
     const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
} // namespace __gnu_cxx







#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 2
# 27 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_memory" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <memory.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/memory

#pragma ifndef PREC_STL_MEMORY
#pragma define PREC_STL_MEMORY
#pragma link off global PREC_STL_MEMORY;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

// Implemented by Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab
# 27 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
//////////////////////////////////////////////////////////////////////


template <class _Tp>
class allocator {
  //typedef alloc _Alloc;          // The underlying allocator.
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef typename _Tp* pointer;
  typedef const typename _Tp * const_pointer;




  typedef _Tp& reference;
  typedef const _Tp& const_reference;
  typedef _Tp value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };

  allocator() ;
  allocator(const allocator&) ;
  //template <class _Tp1> allocator(const allocator<_Tp1>&) ;
  ~allocator() ;

  pointer address(reference __x) const ;
  const_pointer address(const_reference __x) const ;

  // __n is permitted to be 0.  The C++ standard says nothing about what
  // the return value is when __n == 0.
  _Tp* allocate(size_type __n, const void* = 0) ;

  // __p is not permitted to be a null pointer.
  void deallocate(pointer __p, size_type __n);

  size_type max_size() const ;

  void construct(pointer __p, const _Tp& __val) ;
  void destroy(pointer __p) ;
};

template<>
class allocator<void> {
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef void* pointer;
  typedef const void* const_pointer;
  typedef void value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };
};
//////////////////////////////////////////////////////////////////////
# 205 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
//////////////////////////////////////////////////////////////////////

/**********************************************************************
* auto_ptr
**********************************************************************/
template <class X> class auto_ptr {
private:
  X* ptr;
  //template<class Y> struct auto_ptr_ref { };
public:
  typedef X element_type;
  explicit auto_ptr(X* p = 0) : ptr(p) {}
  auto_ptr(auto_ptr& a) {ptr=a.ptr;}

  // this implementation may not be correct
  template <class T> auto_ptr(auto_ptr<T>& a) {ptr=a.release();}
# 229 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
  auto_ptr& operator=(auto_ptr& a) {
    if (a.ptr != ptr) {
      delete ptr;
      ptr = a.ptr;
    }
    return(*this);
  }

  // this implementation may not be correct
  template <class T> auto_ptr& operator=(auto_ptr<T>& a) {
    if (a.ptr != ptr) {
       delete ptr;
       ptr = a.release();
    }
    return(*this);
  }

  ~auto_ptr() { delete ptr; }

  X& operator*() const { return *ptr; }
  X* operator->() const { return ptr; }
  X* get() const { return ptr; }
  X* release() { X *old = ptr; ptr = 0; return 0; }
# 262 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
  // auto_ptr conversions
  //auto_ptr(auto_ptr_ref<X>& x) { }
  //template<class Y> operator auto_ptr_ref<Y>() { return auto_ptr_ref<Y>(); }
  //template<class Y> operator auto_ptr<Y>() { return auto_ptr<T>(); }
};

#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_memory" 2
# 28 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_utility" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <utility.dll>


#pragma include_noerr <pair.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/utility" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/utility

#pragma ifndef PREC_STL_UTILITY
#pragma define PREC_STL_UTILITY
#pragma link off global PREC_STL_UTILITY;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

template <class T1, class T2>
struct pair {
  T1 first;
  T2 second;
  pair() : first(T1()), second(T2()) {}
  pair(const T1& a, const T2& b) : first(a), second(b) {}
 private:
  pair& operator=(const pair& x){first=x.first;second=x.second;return *this;}
};

#pragma endif
# 17 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_utility" 2
# 29 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector" 2
# 37 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
template<class T,class Allocator=std::allocator<T> >
# 49 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
class vector {
 public:
  typedef T value_type;


  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
# 218 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
  class iterator {
   public:
     typedef vector::pointer pointer;
     typedef vector::const_pointer const_pointer;
     typedef vector::reference reference;
     typedef vector::const_reference const_reference;
     typedef vector::size_type size_type;
     typedef vector::difference_type difference_type;

      iterator();
      explicit iterator(const pointer& __i) ;
      // Allow iterator to const_iterator conversion
      template<typename _Iter> inline iterator(const iterator& __i);

      // Forward iterator requirements
      reference operator*() const ;
      pointer operator->() const ;
      iterator& operator++();
      iterator operator++(int) ;

      // Bidirectional iterator requirements
      iterator& operator--() ;
      iterator operator--(int) ;

      // Random access iterator requirements
      reference operator[](const difference_type& __n) const;
      iterator& operator+=(const difference_type& __n);
      iterator operator+(const difference_type& __n) const;
      iterator& operator-=(const difference_type& __n);
      iterator operator-(const difference_type& __n) const;
      const pointer& base() const ;

      iterator operator=(const iterator& x) ;

  };

  friend bool operator==(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator!=(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator<(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator>(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator<=(const vector::iterator& x,const vector::iterator& y)const;
  friend bool operator>=(const vector::iterator& x,const vector::iterator& y)const;
  friend vector::iterator::difference_type operator-(const vector::iterator& x,const vector::iterator& y)const;
  friend vector::iterator operator+(const vector::iterator::difference_type x,const vector::iterator& y)const;

  typedef const iterator const_iterator;
# 355 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator> reverse_iterator;
# 398 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
  friend bool operator==(const vector::reverse_iterator& x
                        ,const vector::reverse_iterator& y) const;
  friend bool operator!=(const vector::reverse_iterator& x
                        ,const vector::reverse_iterator& y) const;






  friend bool operator==(vector::const_iterator& x
                        ,vector::const_iterator& y) const;
  friend bool operator!=(vector::const_iterator& x
                        ,vector::const_iterator& y) const;
# 422 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
  reference at(size_type n);
  const_reference at(size_type n) const;

  iterator begin(void) ;
  iterator end(void) ;
  reverse_iterator rbegin(void) ;
  reverse_iterator rend(void) ;






  size_type size(void) const ;
  size_type max_size(void) const ;
  void resize(size_type sz) ;
  void resize(size_type sz, T c) ;
  size_type capacity(void) const ;
  bool empty(void) const ;
  reference operator[](size_type n) ;
  const_reference operator[](size_type n) const;
  vector(void) ;
  vector(size_type n,const T& value=T()) ;
  vector(const vector& x) ;
  vector(const_iterator first,const_iterator last) ;
  ~vector(void) ;
  vector& operator=(const vector& x);
  void reserve(size_type n) ;
  T& front(void) ;
  T& back(void) ;
  void push_back(const T& x) ;
  void swap(vector& x);
  iterator insert(iterator position,const T& x);
  void insert(iterator position,const_iterator first,const_iterator last);
  void insert(iterator position,size_type n,const T& x);
  void pop_back(void) ;
  void erase(iterator position) ;
  void erase(iterator first,iterator last) ;
  void clear() ;


  friend bool operator==(const vector& x, const vector& y);
  friend bool operator< (const vector& x, const vector& y);
  friend bool operator!=(const vector& x, const vector& y);
  friend bool operator> (const vector& x, const vector& y);
  friend bool operator>=(const vector& x, const vector& y);
  friend bool operator<=(const vector& x, const vector& y);



  // specialized algorithms:






#pragma ifndef G__NOALGORITHM

  // Generic algorithm


  // input iter
  friend vector::iterator
    find(vector::iterator first,vector::iterator last,const T& value);
  // forward iter
  friend vector::iterator
    find_end(vector::iterator first1,vector::iterator last1,
      vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    find_first_of(vector::iterator first1,vector::iterator last1,
           vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    adjacent_find(vector::iterator first,vector::iterator last);
  // input iter

  friend vector::difference_type
    count(vector::iterator first,vector::iterator last,const T& value);






  friend bool
    equal(vector::iterator first1,vector::iterator last1,
          vector::iterator first2);
  // forward iter
  friend vector::iterator
    search(vector::iterator first1,vector::iterator last1,
           vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    search_n(vector::iterator first,vector::iterator last
             ,vector::size_type count,const T& value);
  // input and output iter -> forward iter
  friend vector::iterator
    copy(vector::iterator first,vector::iterator last,
         vector::iterator result);
  // bidirectional iter
  friend vector::iterator
    copy_backward(vector::iterator first,vector::iterator last,
                  vector::iterator result);
  // just value_type
  friend void swap(T& a,T& b);
  // forward iter
  friend vector::iterator
    swap_ranges(vector::iterator first1,vector::iterator last1,
                vector::iterator first2);
  friend void iter_swap(vector::iterator a,vector::iterator b);
  friend void replace(vector::iterator first,vector::iterator last,
                      const T& old_value,const T& new_value);
  // input, output iter -> forward iter
  friend vector::iterator
    replace_copy(vector::iterator first,vector::iterator last,
                 vector::iterator result,
                 const T& old_value,const T& new_value);
  // forward iter
  friend void
    fill(vector::iterator first,vector::iterator last,const T& value);

  friend void
    fill_n(vector::iterator first,vector::size_type n,const T& value);

  friend vector::iterator
    remove(vector::iterator first,vector::iterator last,const T& value);
  // input,output iter -> forward iter
  friend vector::iterator
    remove_copy(vector::iterator first,vector::iterator last,
                vector::iterator result,const T& value);
  friend vector::iterator
    unique(vector::iterator first,vector::iterator last);
  friend vector::iterator
    unique_copy(vector::iterator first,vector::iterator last,
                vector::iterator result);
  friend void reverse(vector::iterator first,vector::iterator last);
  friend vector::iterator
     reverse_copy(vector::iterator first,vector::iterator last,
                  vector::iterator result);
  // forward iter

  friend void rotate(vector::iterator first,vector::iterator mid,
                     vector::iterator last);

  // forward iter
  friend vector::iterator
    rotate_copy(vector::iterator first,vector::iterator mid,
                vector::iterator last,vector::iterator result);
  // randomaccess iter
  friend void random_shuffle(vector::iterator first,vector::iterator last);
  // randomaccess iter
  friend void sort(vector::iterator first,vector::iterator last);
  friend void stable_sort(vector::iterator first,vector::iterator last);
  friend void partial_sort(vector::iterator first,vector::iterator mid,
                           vector::iterator last);
  friend vector::iterator
    partial_sort_copy(vector::iterator first,vector::iterator last,
                      vector::iterator result_first,
                      vector::iterator result_last);
  friend void nth_element(vector::iterator first,vector::iterator nth,
                          vector::iterator last);
  // forward iter
  friend vector::iterator
    lower_bound(vector::iterator first,vector::iterator last,const T& value);
  friend vector::iterator
    upper_bound(vector::iterator first,vector::iterator last,const T& value);




  friend bool binary_search(vector::iterator first,vector::iterator last,
                            const T& value);
  friend vector::iterator merge(vector::iterator first1,vector::iterator last1,
                                vector::iterator first2,vector::iterator last2,
                                vector::iterator result);
  friend void inplace_merge(vector::iterator first,vector::iterator middle,
                            vector::iterator last);
  friend bool includes(vector::iterator first1,vector::iterator last1,
                       vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    set_union(vector::iterator first1,vector::iterator last1,
              vector::iterator first2,vector::iterator last2,
              vector::iterator result);
  friend vector::iterator
    set_intersection(vector::iterator first1,vector::iterator last1,
                     vector::iterator first2,vector::iterator last2,
                     vector::iterator result);
  friend vector::iterator
    set_difference(vector::iterator first1,vector::iterator last1,
                   vector::iterator first2,vector::iterator last2,
                   vector::iterator result);
  friend vector::iterator
    set_symmetric_difference(vector::iterator first1,vector::iterator last1,
                             vector::iterator first2,vector::iterator last2,
                             vector::iterator result);
  // random access
  friend void push_heap(vector::iterator first,vector::iterator last);
  friend void pop_heap(vector::iterator first,vector::iterator last);
  friend void make_heap(vector::iterator first,vector::iterator last);
  friend void sort_heap(vector::iterator first,vector::iterator last);
  // min,max, just value_type
  friend const T& min(const T& a,const T& b);
  friend const T& max(const T& a,const T& b);
  // forward iter
  friend vector::iterator
    min_element(vector::iterator first,vector::iterator last);
  friend vector::iterator
    max_element(vector::iterator first,vector::iterator last);
  // input iter
  friend bool
    lexicographical_compare(vector::iterator first1,vector::iterator last1,
                            vector::iterator first2,vector::iterator last2);
  // bidirectional iter
  friend bool next_permutation(vector::iterator first,vector::iterator last);
  friend bool prev_permutation(vector::iterator first,vector::iterator last);
# 662 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
#pragma endif

  // iterator_category resolution
  //friend random_access_iterator_tag iterator_category(vector::iterator x);

};
# 837 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/vector"
#pragma endif
# 15 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_vector" 2
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/vector" 2
}
# 35 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TInetAddress.h" 2





class TInetAddress : public TObject {

friend class TSystem;
friend class TUnixSystem;
friend class TWinNTSystem;
friend class TUUID;
friend class TSocket;
friend class TUDPSocket;
friend class TServerSocket;
friend class TXSocket; // special for BaBar

public:
   typedef std::vector<UInt_t> AddressList_t;
   typedef std::vector<TString> AliasList_t;

private:
   TString fHostname; // fully qualified hostname
   Int_t fFamily; // address family
   Int_t fPort; // port through which we are connected
   AddressList_t fAddresses; // list of all IP addresses in host byte order
   AliasList_t fAliases; // list of aliases

   TInetAddress(const char *host, UInt_t addr, Int_t family, Int_t port = -1);
   void AddAddress(UInt_t addr);
   void AddAlias(const char *alias);

public:
   TInetAddress();
   TInetAddress(const TInetAddress &adr);
   TInetAddress &operator=(const TInetAddress &rhs);
   virtual ~TInetAddress() { }

   UInt_t GetAddress() const { return fAddresses[0]; }
   UChar_t *GetAddressBytes() const;
   const char *GetHostAddress() const;
   const char *GetHostName() const { return (const char *) fHostname; }
   Int_t GetFamily() const { return fFamily; }
   Int_t GetPort() const { return fPort; }
   const AddressList_t &GetAddresses() const { return fAddresses; }
   const AliasList_t &GetAliases() const { return fAliases; }
   Bool_t IsValid() const { return fFamily == -1 ? kFALSE : kTRUE; }
   void Print(Option_t *option="") const;

   static const char *GetHostAddress(UInt_t addr);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 4; } static void Dictionary(); virtual TClass *IsA() const { return TInetAddress::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TInetAddress::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TInetAddress.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 85; } //Represents an Internet Protocol (IP) address
};
# 42 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTimer.h" 1
// @(#)root/base:$Id: TTimer.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Fons Rademakers   28/11/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TTimer                                                               //
//                                                                      //
// Handles synchronous and a-synchronous timer events. You can use      //
// this class in one of the following ways:                             //
//    - Sub-class TTimer and override the Notify() method.              //
//    - Re-implement the TObject::HandleTimer() method in your class    //
//      and pass a pointer to this object to timer, see the SetObject() //
//      method.                                                         //
//    - Pass an interpreter command to timer, see SetCommand() method.  //
//    - Create a TTimer, connect its Timeout() signal to the            //
//      appropriate methods. Then when the time is up it will emit a    //
//      Timeout() signal and call connected slots.                      //
//                                                                      //
//  Minimum timeout interval is defined in TSystem::ESysConstants as    //
//  kItimerResolution (currently 10 ms).                                //
//                                                                      //
//  Signal/slots example:                                               //
//       TTimer *timer = new TTimer();                                  //
//       timer->Connect("Timeout()", "myObjectClassName",               //
//                      myObject, "TimerDone()");                       //
//       timer->Start(2000, kTRUE);   // 2 seconds single-shot          //
//                                                                      //
//    // Timeout signal is emitted repeadetly with minimum timeout      //
//    // timer->Start(0, kFALSE);                                       //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSysEvtHandler.h" 1
// @(#)root/base:$Id: TSysEvtHandler.h 21455 2007-12-18 15:44:33Z rdm $
// Author: Fons Rademakers   16/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TSysEvtHandler                                                       //
//                                                                      //
// Abstract base class for handling system events.                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSysEvtHandler.h"
class TSysEvtHandler : public TObject, public TQObject {

private:
   Bool_t fIsActive; // kTRUE if handler is active, kFALSE if not active

   void *GetSender() { return this; } //used to set gTQSender

public:
   TSysEvtHandler() : fIsActive(kTRUE) { }
   virtual ~TSysEvtHandler() { }

   void Activate();
   void DeActivate();
   Bool_t IsActive() const { return fIsActive; }

   virtual void Add() = 0;
   virtual void Remove() = 0;
   virtual Bool_t Notify() = 0;

   virtual void Activated() { Emit("Activated()"); } //*SIGNAL*
   virtual void DeActivated() { Emit("DeActivated()"); } //*SIGNAL*
   virtual void Notified() { Emit("Notified()"); } //*SIGNAL*
   virtual void Added() { Emit("Added()"); } //*SIGNAL*
   virtual void Removed() { Emit("Removed()"); } //*SIGNAL*

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TSysEvtHandler::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TSysEvtHandler::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSysEvtHandler.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 57; } //ABC for handling system events
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TFileHandler                                                         //
//                                                                      //
// Handles events on file descriptors.                                  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TFileHandler : public TSysEvtHandler {

protected:
   int fFileNum; //File descriptor
   int fMask; //Event interest mask, either bit 1 (read), 2 (write) or both can be set
   int fReadyMask; //Readiness mask, either bit 1 (read), 2 (write) or both can be set

   TFileHandler(): fFileNum(-1), fMask(0), fReadyMask(0) { }

public:
   enum { kRead = 1, kWrite = 2 };

   TFileHandler(int fd, int mask);
   virtual ~TFileHandler() { Remove(); }
   int GetFd() const { return fFileNum; }
   void SetFd(int fd) { fFileNum = fd; }
   virtual Bool_t Notify();
   virtual Bool_t ReadNotify();
   virtual Bool_t WriteNotify();
   virtual Bool_t HasReadInterest();
   virtual Bool_t HasWriteInterest();
   virtual void SetInterest(Int_t mask);
   virtual void ResetReadyMask() { fReadyMask = 0; }
   virtual void SetReadReady() { fReadyMask |= 0x1; }
   virtual void SetWriteReady() { fReadyMask |= 0x2; }
   virtual Bool_t IsReadReady() const { return (fReadyMask & 0x1) == 0x1; }
   virtual Bool_t IsWriteReady() const { return (fReadyMask & 0x2) == 0x2; }
   virtual void Add();
   virtual void Remove();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TFileHandler::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TFileHandler::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSysEvtHandler.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 99; } //Handles events on file descriptors
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TSignalHandler                                                       //
//                                                                      //
// Handles signals.                                                     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

enum ESignals {
   kSigBus,
   kSigSegmentationViolation,
   kSigSystem,
   kSigPipe,
   kSigIllegalInstruction,
   kSigQuit,
   kSigInterrupt,
   kSigWindowChanged,
   kSigAlarm,
   kSigChild,
   kSigUrgent,
   kSigFloatingException,
   kSigTermination,
   kSigUser1,
   kSigUser2
};


class TSignalHandler : public TSysEvtHandler {

protected:
   ESignals fSignal; //Signal to be handled
   Bool_t fSync; //Synchronous or a-synchronous signal
   Int_t fDelay; //Delay handling of signal (use fDelay in Notify())

   TSignalHandler(): fSignal((ESignals)-1), fSync(kTRUE), fDelay(0) { }

public:
   TSignalHandler(ESignals sig, Bool_t sync = kTRUE);
   virtual ~TSignalHandler() { Remove(); }
   void Delay() { fDelay = 1; }
   void HandleDelayedSignal();
   ESignals GetSignal() const { return fSignal; }
   void SetSignal(ESignals sig) { fSignal = sig; }
   Bool_t IsSync() const { return fSync; }
   Bool_t IsAsync() const { return !fSync; }
   virtual Bool_t Notify();
   virtual void Add();
   virtual void Remove();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TSignalHandler::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TSignalHandler::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSysEvtHandler.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 152; } //Signal event handler
};

inline void TSignalHandler::HandleDelayedSignal()
{
   if (fDelay > 1) {
      fDelay = 0;
      Notify();
   } else
      fDelay = 0;
}


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TStdExceptionHandler                                                 //
//                                                                      //
// Handles standard C++ exceptions.                                     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

namespace std { class exception; }

class TStdExceptionHandler : public TSysEvtHandler {

public:
   enum EStatus { kSEProceed, kSEHandled, kSEAbort };

   TStdExceptionHandler();
   virtual ~TStdExceptionHandler() { }

   virtual void Add();
   virtual void Remove();
   virtual Bool_t Notify();

   virtual EStatus Handle(std::exception& exc) = 0;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TStdExceptionHandler::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TStdExceptionHandler::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSysEvtHandler.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 189; } //C++ exception handler
};
# 47 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTimer.h" 2


# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTime.h" 1
// @(#)root/base:$Id: TTime.h 34556 2010-07-22 15:10:17Z rdm $
// Author: Fons Rademakers   28/11/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TTime                                                                //
//                                                                      //
// Basic time type with millisecond precision.                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////






class TTime {

private:
   Long64_t fMilliSec; // time with millisecond precision

public:
   TTime(): fMilliSec(0) { }
   TTime(Long64_t msec): fMilliSec(msec) { }
   TTime(const TTime &t): fMilliSec(t.fMilliSec) { }
   virtual ~TTime() { }

   TTime& operator=(const TTime &t);

   TTime operator+=(const TTime &t);
   TTime operator-=(const TTime &t);
   TTime operator*=(const TTime &t);
   TTime operator/=(const TTime &t);

   friend TTime operator+(const TTime &t1, const TTime &t2);
   friend TTime operator-(const TTime &t1, const TTime &t2);
   friend TTime operator*(const TTime &t1, const TTime &t2);
   friend TTime operator/(const TTime &t1, const TTime &t2);

   friend Bool_t operator== (const TTime &t1, const TTime &t2);
   friend Bool_t operator!= (const TTime &t1, const TTime &t2);
   friend Bool_t operator< (const TTime &t1, const TTime &t2);
   friend Bool_t operator<= (const TTime &t1, const TTime &t2);
   friend Bool_t operator> (const TTime &t1, const TTime &t2);
   friend Bool_t operator>= (const TTime &t1, const TTime &t2);

   operator long() const;
   operator unsigned long() const;
   operator long long() const;
   operator unsigned long long() const;
   const char *AsString() const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TTime::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TTime::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTime.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 65; } //Basic time type with milli second precision
};

inline TTime& TTime::operator= (const TTime &t)
   { fMilliSec = t.fMilliSec; return *this; }
inline TTime TTime::operator+=(const TTime &t)
   { fMilliSec += t.fMilliSec; return *this; }
inline TTime TTime::operator-=(const TTime &t)
   { fMilliSec -= t.fMilliSec; return *this; }
inline TTime TTime::operator*=(const TTime &t)
   { fMilliSec *= t.fMilliSec; return *this; }
inline TTime TTime::operator/=(const TTime &t)
   { fMilliSec /= t.fMilliSec; return *this; }
inline TTime::operator long long() const
   { return fMilliSec; }
inline TTime::operator unsigned long long() const
   { return (ULong64_t) fMilliSec; }

inline TTime operator+(const TTime &t1, const TTime &t2)
   { return TTime(t1.fMilliSec + t2.fMilliSec); }
inline TTime operator-(const TTime &t1, const TTime &t2)
   { return TTime(t1.fMilliSec - t2.fMilliSec); }
inline TTime operator*(const TTime &t1, const TTime &t2)
   { return TTime(t1.fMilliSec * t2.fMilliSec); }
inline TTime operator/(const TTime &t1, const TTime &t2)
   { return TTime(t1.fMilliSec / t2.fMilliSec); }

inline Bool_t operator== (const TTime &t1, const TTime &t2)
   { return t1.fMilliSec == t2.fMilliSec; }
inline Bool_t operator!= (const TTime &t1, const TTime &t2)
   { return t1.fMilliSec != t2.fMilliSec; }
inline Bool_t operator< (const TTime &t1, const TTime &t2)
   { return t1.fMilliSec < t2.fMilliSec; }
inline Bool_t operator<= (const TTime &t1, const TTime &t2)
   { return t1.fMilliSec <= t2.fMilliSec; }
inline Bool_t operator> (const TTime &t1, const TTime &t2)
   { return t1.fMilliSec > t2.fMilliSec; }
inline Bool_t operator>= (const TTime &t1, const TTime &t2)
   { return t1.fMilliSec >= t2.fMilliSec; }
# 50 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTimer.h" 2







class TTimer : public TSysEvtHandler {

protected:
   TTime fTime; // time out time in ms
   TTime fAbsTime; // absolute time out time in ms
   Bool_t fTimeout; // true if timer has timed out
   Bool_t fSync; // true if synchrounous timer
   Bool_t fIntSyscalls; // true is a-synchronous timer is to interrupt system calls
   UInt_t fTimeID; // the system ID of this timer (for WIN32)
   TObject *fObject; // object to be notified (if any)
   TString fCommand; // interpreter command to be executed

private:
   TTimer(const TTimer&); // not implemented
   TTimer& operator=(const TTimer&); // not implemented

public:
   TTimer(Long_t milliSec = 0, Bool_t mode = kTRUE);
   TTimer(TObject *obj, Long_t milliSec, Bool_t mode = kTRUE);
   TTimer(const char *command, Long_t milliSec, Bool_t mode = kTRUE);
   virtual ~TTimer() { Remove(); }

   Bool_t CheckTimer(const TTime &now);
   const char *GetCommand() const { return fCommand.Data(); }
   TObject *GetObject() { return fObject; }
   TTime GetTime() const { return fTime; }
   UInt_t GetTimerID() { return fTimeID;}
   TTime GetAbsTime() const { return fAbsTime; }
   Bool_t HasTimedOut() const { return fTimeout; }
   Bool_t IsSync() const { return fSync; }
   Bool_t IsAsync() const { return !fSync; }
   Bool_t IsInterruptingSyscalls() const { return fIntSyscalls; }
   virtual Bool_t Notify();
   void Add() { TurnOn(); }
   void Remove() { TurnOff(); }
   void Reset();
   void SetCommand(const char *command);
   void SetObject(TObject *object);
   void SetInterruptSyscalls(Bool_t set = kTRUE);
   void SetTime(Long_t milliSec) { fTime = milliSec; }
   void SetTimerID(UInt_t id = 0) { fTimeID = id; }
   virtual void Start(Long_t milliSec = -1, Bool_t singleShot = kFALSE);
   virtual void Stop() { TurnOff(); }
   virtual void TurnOn(); //*SIGNAL*
   virtual void TurnOff(); //*SIGNAL*
   virtual void Timeout() { Emit("Timeout()"); } //*SIGNAL*

   static void SingleShot(Int_t milliSec, const char *receiver_class,
                             void *receiver, const char *method);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TTimer::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TTimer::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTimer.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 107; } //Handle timer event
};
# 45 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h" 2


class TSeqCollection;
class TFdSet;
class TVirtualMutex;

enum EAccessMode {
   kFileExists = 0,
   kExecutePermission = 1,
   kWritePermission = 2,
   kReadPermission = 4
};

enum ELogOption {
   kLogPid = 0x01,
   kLogCons = 0x02
};

enum ELogLevel {
   kLogEmerg = 0,
   kLogAlert = 1,
   kLogCrit = 2,
   kLogErr = 3,
   kLogWarning = 4,
   kLogNotice = 5,
   kLogInfo = 6,
   kLogDebug = 7
};

enum ELogFacility {
   kLogLocal0,
   kLogLocal1,
   kLogLocal2,
   kLogLocal3,
   kLogLocal4,
   kLogLocal5,
   kLogLocal6,
   kLogLocal7
};

enum ESysConstants {
   kMAXSIGNALS = 15,
   kMAXPATHLEN = 8192,
   kBUFFERSIZE = 8192,
   kItimerResolution = 10 // interval-timer resolution in ms
};

enum EFpeMask {
   kNoneMask = 0x00,
   kInvalid = 0x01, // Invalid argument
   kDivByZero = 0x02, // Division by zero
   kOverflow = 0x04, // Overflow
   kUnderflow = 0x08, // Underflow
   kInexact = 0x10, // Inexact
   kDefaultMask = 0x07,
   kAllMask = 0x1F
};

enum EFileModeMask {
   kS_IFMT = 0170000, // bitmask for the file type bitfields
   kS_IFSOCK = 0140000, // socket
   kS_IFLNK = 0120000, // symbolic link
   kS_IFOFF = 0110000, // offline file
   kS_IFREG = 0100000, // regular file
   kS_IFBLK = 0060000, // block device
   kS_IFDIR = 0040000, // directory
   kS_IFCHR = 0020000, // character device
   kS_IFIFO = 0010000, // fifo
   kS_ISUID = 0004000, // set UID bit
   kS_ISGID = 0002000, // set GID bit
   kS_ISVTX = 0001000, // sticky bit
   kS_IRWXU = 00700, // mask for file owner permissions
   kS_IRUSR = 00400, // owner has read permission
   kS_IWUSR = 00200, // owner has write permission
   kS_IXUSR = 00100, // owner has execute permission
   kS_IRWXG = 00070, // mask for group permissions
   kS_IRGRP = 00040, // group has read permission
   kS_IWGRP = 00020, // group has write permission
   kS_IXGRP = 00010, // group has execute permission
   kS_IRWXO = 00007, // mask for permissions for others (not in group)
   kS_IROTH = 00004, // others have read permission
   kS_IWOTH = 00002, // others have write permisson
   kS_IXOTH = 00001 // others have execute permission
};

inline Bool_t R_ISDIR(Int_t mode) { return ((mode & kS_IFMT) == kS_IFDIR); }
inline Bool_t R_ISCHR(Int_t mode) { return ((mode & kS_IFMT) == kS_IFCHR); }
inline Bool_t R_ISBLK(Int_t mode) { return ((mode & kS_IFMT) == kS_IFBLK); }
inline Bool_t R_ISREG(Int_t mode) { return ((mode & kS_IFMT) == kS_IFREG); }
inline Bool_t R_ISLNK(Int_t mode) { return ((mode & kS_IFMT) == kS_IFLNK); }
inline Bool_t R_ISFIFO(Int_t mode) { return ((mode & kS_IFMT) == kS_IFIFO); }
inline Bool_t R_ISSOCK(Int_t mode) { return ((mode & kS_IFMT) == kS_IFSOCK); }
inline Bool_t R_ISOFF(Int_t mode) { return ((mode & kS_IFMT) == kS_IFOFF); }

struct FileStat_t {
   Long_t fDev; // device id
   Long_t fIno; // inode
   Int_t fMode; // protection (combination of EFileModeMask bits)
   Int_t fUid; // user id of owner
   Int_t fGid; // group id of owner
   Long64_t fSize; // total size in bytes
   Long_t fMtime; // modification date
   Bool_t fIsLink; // symbolic link
   TString fUrl; // end point url of file
   FileStat_t() : fDev(0), fIno(0), fMode(0), fUid(0), fGid(0), fSize(0),
                  fMtime(0), fIsLink(kFALSE), fUrl("") { }
};

struct UserGroup_t {
   Int_t fUid; // user id
   Int_t fGid; // group id
   TString fUser; // user name
   TString fGroup; // group name
   TString fPasswd; // password
   TString fRealName; // user full name
   TString fShell; // user preferred shell
   UserGroup_t() : fUid(0), fGid(0), fUser(), fGroup(), fPasswd(),
                   fRealName (), fShell() { }
};

struct SysInfo_t {
   TString fOS; // OS
   TString fModel; // computer model
   TString fCpuType; // type of cpu
   Int_t fCpus; // number of cpus
   Int_t fCpuSpeed; // cpu speed in MHz
   Int_t fBusSpeed; // bus speed in MHz
   Int_t fL2Cache; // level 2 cache size in KB
   Int_t fPhysRam; // physical RAM in MB
   SysInfo_t() : fOS(), fModel(), fCpuType(), fCpus(0), fCpuSpeed(0),
                 fBusSpeed(0), fL2Cache(0), fPhysRam(0) { }
   virtual ~SysInfo_t() { }
   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return SysInfo_t::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { SysInfo_t::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 177; }; // System information - OS, CPU, RAM.
};

struct CpuInfo_t {
   Float_t fLoad1m; // cpu load average over 1 m
   Float_t fLoad5m; // cpu load average over 5 m
   Float_t fLoad15m; // cpu load average over 15 m
   Float_t fUser; // cpu user load in percentage
   Float_t fSys; // cpu sys load in percentage
   Float_t fTotal; // cpu user+sys load in percentage
   Float_t fIdle; // cpu idle percentage
   CpuInfo_t() : fLoad1m(0), fLoad5m(0), fLoad15m(0),
                 fUser(0), fSys(0), fTotal(0), fIdle(0) { }
   virtual ~CpuInfo_t() { }
   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return CpuInfo_t::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { CpuInfo_t::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 191; }; // CPU load information.
};

struct MemInfo_t {
   Int_t fMemTotal; // total RAM in MB
   Int_t fMemUsed; // used RAM in MB
   Int_t fMemFree; // free RAM in MB
   Int_t fSwapTotal; // total swap in MB
   Int_t fSwapUsed; // used swap in MB
   Int_t fSwapFree; // free swap in MB
   MemInfo_t() : fMemTotal(0), fMemUsed(0), fMemFree(0),
                 fSwapTotal(0), fSwapUsed(0), fSwapFree(0) { }
   virtual ~MemInfo_t() { }
   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return MemInfo_t::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { MemInfo_t::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 204; }; // Memory utilization information.
};

struct ProcInfo_t {
   Float_t fCpuUser; // user time used by this process in seconds
   Float_t fCpuSys; // system time used by this process in seconds
   Long_t fMemResident; // resident memory used by this process in KB
   Long_t fMemVirtual; // virtual memory used by this process in KB
   ProcInfo_t() : fCpuUser(0), fCpuSys(0), fMemResident(0),
                  fMemVirtual(0) { }
   virtual ~ProcInfo_t() { }
   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return ProcInfo_t::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { ProcInfo_t::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 215; };// System resource usage of given process.
};

struct RedirectHandle_t {
   TString fFile; // File where the output was redirected
   TString fStdOutTty; // tty associated with stdout, if any (e.g. from ttyname(...))
   TString fStdErrTty; // tty associated with stderr, if any (e.g. from ttyname(...))
   Int_t fStdOutDup; // Duplicated descriptor for stdout
   Int_t fStdErrDup; // Duplicated descriptor for stderr
   Int_t fReadOffSet; // Offset where to start reading the file (used by ShowOutput(...))
   RedirectHandle_t(const char *n = 0) : fFile(n), fStdOutTty(), fStdErrTty(), fStdOutDup(-1),
                                         fStdErrDup(-1), fReadOffSet(-1) { }
   void Reset() { fFile = ""; fStdOutTty = ""; fStdErrTty = "";
                  fStdOutDup = -1; fStdErrDup = -1; fReadOffSet = -1; }
};


typedef void *Func_t;




extern const char *gRootDir;
extern const char *gProgName;
extern const char *gProgPath;
extern TVirtualMutex *gSystemMutex;


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Asynchronous timer used for processing pending GUI and timer events  //
// every delay ms. Call in a tight computing loop                       //
// TProcessEventTimer::ProcessEvent(). If the timer did timeout this    //
// call will process the pending events and return kTRUE if the         //
// TROOT::IsInterrupted() flag is set (can be done by hitting key in    //
// canvas or selecting canvas menu item View/Interrupt.                 //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
class TProcessEventTimer : public TTimer {
public:
   TProcessEventTimer(Long_t delay);
   Bool_t Notify() { return kTRUE; }
   Bool_t ProcessEvents();
   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TProcessEventTimer::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TProcessEventTimer::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 258; } // Process pending events at fixed time intervals
};


class TSystem : public TNamed {

public:
   enum EAclicMode { kDefault, kDebug, kOpt };
   enum EAclicProperties {
      kFlatBuildDir = (1ULL << (0)) // If set and a BuildDir is selected, then do not created subdirectories
   };

protected:
   TFdSet *fReadmask; //!Files that should be checked for read events
   TFdSet *fWritemask; //!Files that should be checked for write events
   TFdSet *fReadready; //!Files with reads waiting
   TFdSet *fWriteready; //!Files with writes waiting
   TFdSet *fSignals; //!Signals that were trapped
   Int_t fNfd; //Number of fd's in masks
   Int_t fMaxrfd; //Largest fd in read mask
   Int_t fMaxwfd; //Largest fd in write mask
   Int_t fSigcnt; //Number of pending signals
   TString fWdpath; //Working directory
   TString fHostname; //Hostname
   Bool_t fInsideNotify; //Used by DispatchTimers()
   Int_t fBeepFreq; //Used by Beep()
   Int_t fBeepDuration; //Used by Beep()

   Bool_t fInControl; //True if in eventloop
   Bool_t fDone; //True if eventloop should be finished
   Int_t fLevel; //Level of nested eventloops
   TString fLastErrorString; //Last system error message

   TSeqCollection *fTimers; //List of timers
   TSeqCollection *fSignalHandler; //List of signal handlers
   TSeqCollection *fFileHandler; //List of file handlers
   TSeqCollection *fStdExceptionHandler; //List of std::exception handlers
   TSeqCollection *fOnExitList; //List of items to be cleaned-up on exit

   TString fListLibs; //List shared libraries, cache used by GetLibraries

   TString fBuildArch; //Architecure for which ROOT was built (passed to ./configure)
   TString fBuildCompiler; // Compiler used to build this ROOT
   TString fBuildCompilerVersion; //Compiler version used to build this ROOT
   TString fBuildNode; //Detailed information where ROOT was built
   TString fBuildDir; //Location where to build ACLiC shared library and use as scratch area.
   TString fFlagsDebug; //Flags for debug compilation
   TString fFlagsOpt; //Flags for optimized compilation
   TString fListPaths; //List of all include (fIncludePath + interpreter include path). Cache used by GetIncludePath
   TString fIncludePath; //Used to expand $IncludePath in the directives given to SetMakeSharedLib and SetMakeExe
   TString fLinkedLibs; //Used to expand $LinkedLibs in the directives given to SetMakeSharedLib and SetMakeExe
   TString fSoExt; //Extension of shared library (.so, .sl, .a, .dll, etc.)
   TString fObjExt; //Extension of object files (.o, .obj, etc.)
   EAclicMode fAclicMode; //Whether the compilation should be done debug or opt
   TString fMakeSharedLib; //Directive used to build a shared library
   TString fMakeExe; //Directive used to build an executable
   TString fLinkdefSuffix; //Default suffix for linkdef files to be used by ACLiC (see EACLiCProperties)
   Int_t fAclicProperties; //Various boolean flag for change ACLiC's behavior.
   TSeqCollection *fCompiled; //List of shared libs from compiled macros to be deleted
   TSeqCollection *fHelpers; //List of helper classes for alternative file/directory access

   TSystem *FindHelper(const char *path, void *dirptr = 0);
   virtual Bool_t ConsistentWith(const char *path, void *dirptr = 0);
   virtual const char *ExpandFileName(const char *fname);
   virtual void SigAlarmInterruptsSyscalls(Bool_t) { }
   virtual const char *GetLinkedLibraries();
   virtual void DoBeep(Int_t /*freq*/=-1, Int_t /*duration*/=-1) const { printf("\a"); fflush(stdout); }

   static const char *StripOffProto(const char *path, const char *proto) {
      return !strncmp(path, proto, strlen(proto)) ? path + strlen(proto) : path;
   }

private:
   TSystem(const TSystem&); // not implemented
   TSystem& operator=(const TSystem&); // not implemented

public:
   TSystem(const char *name = "Generic", const char *title = "Generic System");
   virtual ~TSystem();

   //---- Misc
   virtual Bool_t Init();
   virtual void SetProgname(const char *name);
   virtual void SetDisplay();
   void SetErrorStr(const char *errstr);
   const char *GetErrorStr() const { return fLastErrorString; }
   virtual const char *GetError();
   void RemoveOnExit(TObject *obj);
   virtual const char *HostName();
   virtual void NotifyApplicationCreated();

   static Int_t GetErrno();
   static void ResetErrno();
   void Beep(Int_t freq=-1, Int_t duration=-1, Bool_t setDefault=kFALSE);
   void GetBeepDefaults(Int_t &freq, Int_t &duration) const { freq = fBeepFreq; duration = fBeepDuration; }

   //---- EventLoop
   virtual void Run();
   virtual Bool_t ProcessEvents();
   virtual void DispatchOneEvent(Bool_t pendingOnly = kFALSE);
   virtual void ExitLoop();
   Bool_t InControl() const { return fInControl; }
   virtual void InnerLoop();
   virtual Int_t Select(TList *active, Long_t timeout);
   virtual Int_t Select(TFileHandler *fh, Long_t timeout);

   //---- Handling of system events
   virtual void AddSignalHandler(TSignalHandler *sh);
   virtual TSignalHandler *RemoveSignalHandler(TSignalHandler *sh);
   virtual void ResetSignal(ESignals sig, Bool_t reset = kTRUE);
   virtual void ResetSignals();
   virtual void IgnoreSignal(ESignals sig, Bool_t ignore = kTRUE);
   virtual void IgnoreInterrupt(Bool_t ignore = kTRUE);
   virtual TSeqCollection *GetListOfSignalHandlers() const { return fSignalHandler; }
   virtual void AddFileHandler(TFileHandler *fh);
   virtual TFileHandler *RemoveFileHandler(TFileHandler *fh);
   virtual TSeqCollection *GetListOfFileHandlers() const { return fFileHandler; }
   virtual void AddStdExceptionHandler(TStdExceptionHandler *eh);
   virtual TStdExceptionHandler *RemoveStdExceptionHandler(TStdExceptionHandler *eh);
   virtual TSeqCollection *GetListOfStdExceptionHandlers() const { return fStdExceptionHandler; }

   //---- Floating Point Exceptions Control
   virtual Int_t GetFPEMask();
   virtual Int_t SetFPEMask(Int_t mask = kDefaultMask);

   //---- Time & Date
   virtual TTime Now();
   virtual TSeqCollection *GetListOfTimers() const { return fTimers; }
   virtual void AddTimer(TTimer *t);
   virtual TTimer *RemoveTimer(TTimer *t);
   virtual void ResetTimer(TTimer *) { }
   virtual Long_t NextTimeOut(Bool_t mode);
   virtual void Sleep(UInt_t milliSec);

   //---- Processes
   virtual Int_t Exec(const char *shellcmd);
   virtual FILE *OpenPipe(const char *command, const char *mode);
   virtual int ClosePipe(FILE *pipe);
   virtual TString GetFromPipe(const char *command);
   virtual void Exit(int code, Bool_t mode = kTRUE);
   virtual void Abort(int code = 0);
   virtual int GetPid();
   virtual void StackTrace();

   //---- Directories
   virtual int MakeDirectory(const char *name);
   virtual void *OpenDirectory(const char *name);
   virtual void FreeDirectory(void *dirp);
   virtual const char *GetDirEntry(void *dirp);
   virtual void *GetDirPtr() const { return 0; }
   virtual Bool_t ChangeDirectory(const char *path);
   virtual const char *WorkingDirectory();
   virtual const char *HomeDirectory(const char *userName = 0);
   virtual int mkdir(const char *name, Bool_t recursive = kFALSE);
   Bool_t cd(const char *path) { return ChangeDirectory(path); }
   const char *pwd() { return WorkingDirectory(); }
   virtual const char *TempDirectory() const;
   virtual FILE *TempFileName(TString &base, const char *dir = 0);

   //---- Paths & Files
   virtual const char *BaseName(const char *pathname);
   virtual const char *DirName(const char *pathname);
   virtual char *ConcatFileName(const char *dir, const char *name);
   virtual Bool_t IsAbsoluteFileName(const char *dir);
   virtual Bool_t IsFileInIncludePath(const char *name, char **fullpath = 0);
   virtual const char *PrependPathName(const char *dir, TString& name);
   virtual Bool_t ExpandPathName(TString &path);
   virtual char *ExpandPathName(const char *path);
   virtual Bool_t AccessPathName(const char *path, EAccessMode mode = kFileExists);
   virtual Bool_t IsPathLocal(const char *path);
   virtual int CopyFile(const char *from, const char *to, Bool_t overwrite = kFALSE);
   virtual int Rename(const char *from, const char *to);
   virtual int Link(const char *from, const char *to);
   virtual int Symlink(const char *from, const char *to);
   virtual int Unlink(const char *name);
   int GetPathInfo(const char *path, Long_t *id, Long_t *size, Long_t *flags, Long_t *modtime);
   int GetPathInfo(const char *path, Long_t *id, Long64_t *size, Long_t *flags, Long_t *modtime);
   virtual int GetPathInfo(const char *path, FileStat_t &buf);
   virtual int GetFsInfo(const char *path, Long_t *id, Long_t *bsize, Long_t *blocks, Long_t *bfree);
   virtual int Chmod(const char *file, UInt_t mode);
   virtual int Umask(Int_t mask);
   virtual int Utime(const char *file, Long_t modtime, Long_t actime);
   virtual const char *UnixPathName(const char *unixpathname);
   virtual const char *FindFile(const char *search, TString& file, EAccessMode mode = kFileExists);
   virtual char *Which(const char *search, const char *file, EAccessMode mode = kFileExists);
   virtual TList *GetVolumes(Option_t *) const { return 0; }

   //---- Users & Groups
   virtual Int_t GetUid(const char *user = 0);
   virtual Int_t GetGid(const char *group = 0);
   virtual Int_t GetEffectiveUid();
   virtual Int_t GetEffectiveGid();
   virtual UserGroup_t *GetUserInfo(Int_t uid);
   virtual UserGroup_t *GetUserInfo(const char *user = 0);
   virtual UserGroup_t *GetGroupInfo(Int_t gid);
   virtual UserGroup_t *GetGroupInfo(const char *group = 0);

   //---- Environment Manipulation
   virtual void Setenv(const char *name, const char *value);
   virtual void Unsetenv(const char *name);
   virtual const char *Getenv(const char *env);

   //---- System Logging
   virtual void Openlog(const char *name, Int_t options, ELogFacility facility);
   virtual void Syslog(ELogLevel level, const char *mess);
   virtual void Closelog();

   //---- Standard Output redirection
   virtual Int_t RedirectOutput(const char *name, const char *mode = "a", RedirectHandle_t *h = 0);
   virtual void ShowOutput(RedirectHandle_t *h);

   //---- Dynamic Loading
   virtual void AddDynamicPath(const char *pathname);
   virtual const char *GetDynamicPath();
   virtual void SetDynamicPath(const char *pathname);
   virtual char *DynamicPathName(const char *lib, Bool_t quiet = kFALSE);
   virtual Func_t DynFindSymbol(const char *module, const char *entry);
   virtual int Load(const char *module, const char *entry = "", Bool_t system = kFALSE);
   virtual void Unload(const char *module);
   virtual void ListSymbols(const char *module, const char *re = "");
   virtual void ListLibraries(const char *regexp = "");
   virtual const char *GetLibraries(const char *regexp = "",
                                        const char *option = "",
                                        Bool_t isRegexp = kTRUE);

   //---- RPC
   virtual TInetAddress GetHostByName(const char *server);
   virtual TInetAddress GetPeerName(int sock);
   virtual TInetAddress GetSockName(int sock);
   virtual int GetServiceByName(const char *service);
   virtual char *GetServiceByPort(int port);
   virtual int OpenConnection(const char *server, int port, int tcpwindowsize = -1, const char *protocol = "tcp");
   virtual int AnnounceTcpService(int port, Bool_t reuse, int backlog, int tcpwindowsize = -1);
   virtual int AnnounceUdpService(int port, int backlog);
   virtual int AnnounceUnixService(int port, int backlog);
   virtual int AnnounceUnixService(const char *sockpath, int backlog);
   virtual int AcceptConnection(int sock);
   virtual void CloseConnection(int sock, Bool_t force = kFALSE);
   virtual int RecvRaw(int sock, void *buffer, int length, int flag);
   virtual int SendRaw(int sock, const void *buffer, int length, int flag);
   virtual int RecvBuf(int sock, void *buffer, int length);
   virtual int SendBuf(int sock, const void *buffer, int length);
   virtual int SetSockOpt(int sock, int kind, int val);
   virtual int GetSockOpt(int sock, int kind, int *val);

   //---- System, CPU and Memory info
   virtual int GetSysInfo(SysInfo_t *info) const;
   virtual int GetCpuInfo(CpuInfo_t *info, Int_t sampleTime = 1000) const;
   virtual int GetMemInfo(MemInfo_t *info) const;
   virtual int GetProcInfo(ProcInfo_t *info) const;

   //---- ACLiC (Automatic Compiler of Shared Library for CINT)
   virtual void AddIncludePath(const char *includePath);
   virtual void AddLinkedLibs(const char *linkedLib);
   virtual int CompileMacro(const char *filename, Option_t *opt="", const char* library_name = "", const char* build_dir = "", UInt_t dirmode = 0);
   virtual Int_t GetAclicProperties() const;
   virtual const char *GetBuildArch() const;
   virtual const char *GetBuildCompiler() const;
   virtual const char *GetBuildCompilerVersion() const;
   virtual const char *GetBuildNode() const;
   virtual const char *GetBuildDir() const;
   virtual const char *GetFlagsDebug() const;
   virtual const char *GetFlagsOpt() const;
   virtual const char *GetIncludePath();
   virtual const char *GetLinkedLibs() const;
   virtual const char *GetLinkdefSuffix() const;
   virtual EAclicMode GetAclicMode() const;
   virtual const char *GetMakeExe() const;
   virtual const char *GetMakeSharedLib() const;
   virtual const char *GetSoExt() const;
   virtual const char *GetObjExt() const;
   virtual void SetBuildDir(const char* build_dir, Bool_t isflat = kFALSE);
   virtual void SetFlagsDebug(const char *);
   virtual void SetFlagsOpt(const char *);
   virtual void SetIncludePath(const char *includePath);
   virtual void SetMakeExe(const char *directives);
   virtual void SetAclicMode(EAclicMode mode);
   virtual void SetMakeSharedLib(const char *directives);
   virtual void SetLinkedLibs(const char *linkedLibs);
   virtual void SetLinkdefSuffix(const char *suffix);
   virtual void SetSoExt(const char *soExt);
   virtual void SetObjExt(const char *objExt);
   virtual TString SplitAclicMode(const char *filename, TString &mode, TString &args, TString &io) const;
   virtual void CleanCompiledMacros();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TSystem::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TSystem::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 543; } //ABC defining a generic interface to the OS
};

extern TSystem *gSystem;
extern TFileHandler *gXDisplay; // Display server (X11) input event handler
# 19 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBox.h" 1
// @(#)root/graf:$Id: TBox.h 36489 2010-11-03 08:33:25Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 20 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TWbox.h" 1
// @(#)root/graf:$Id: TWbox.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TWbox                                                                //
//                                                                      //
// A window box (box with 3-D effects).                                 //
//                                                                      //
//////////////////////////////////////////////////////////////////////////







# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TColor.h" 1
// @(#)root/base:$Id: TColor.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TColor                                                               //
//                                                                      //
// Color defined by RGB or HLS.                                         //
// At initialization time, a table of colors is generated. This linked  //
// list can be accessed from the ROOT object                            //
// (see TROOT::GetListOfColors()). When a color is defined in the range //
// of [1,50], two "companion" colors are also defined:                  //
//    - the dark version (color_index + 100)                            //
//    - the bright version (color_index + 150)                          //
// The dark and bright color are used to give 3-D effects when drawing  //
// various boxes (see TWbox, TPave, TPaveText, TPaveLabel,etc).         //
//                                                                      //
// This is the list of currently supported basic colors (here dark and  //
// bright colors are not shown).                                        //
//Begin_Html
/*
<img src="gif/colors.gif">
*/
//End_Html
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 47 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TColor.h"
class TColor : public TNamed {
protected:
   Int_t fNumber; //Color number identifier
private:
   Float_t fRed; //Fraction of Red
   Float_t fGreen; //Fraction of Green
   Float_t fBlue; //Fraction of Blue
   Float_t fHue; //Hue
   Float_t fLight; //Light
   Float_t fSaturation; //Saturation
   Float_t fAlpha; //Alpha (transparency)
   static Bool_t fgGrayscaleMode;//if set, GetColor will return grayscale
   static Bool_t fgInitDone; //kTRUE once ROOT colors have been initialized
   static TArrayI fgPalette; //Color palette

   void Allocate();
   static Float_t HLStoRGB1(Float_t rn1, Float_t rn2, Float_t huei);

public:
   TColor();
   TColor(Int_t color, Float_t r, Float_t g, Float_t b, const char *name="", Float_t a = 1);
   TColor(const TColor &color);
   virtual ~TColor();
   const char *AsHexString() const;
   void Copy(TObject &color) const;
   static void CreateColorWheel();
   static void CreateColorsGray();
   static void CreateColorsCircle(Int_t offset, const char *name, UChar_t *rgb);
   static void CreateColorsRectangle(Int_t offset, const char *name, UChar_t *rgb);
   static Int_t CreateGradientColorTable(UInt_t Number, Double_t* Stops,
                    Double_t* Red, Double_t* Green, Double_t* Blue, UInt_t NColors);
   static Int_t GetColorPalette(Int_t i);
   static Int_t GetNumberOfColors();
   virtual void GetRGB(Float_t &r, Float_t &g, Float_t &b) const
                    { r=GetRed(); g=GetGreen(); b=GetBlue(); }
   virtual void GetHLS(Float_t &h, Float_t &l, Float_t &s) const
                    { h=GetHue(); l=GetLight(); s=GetSaturation(); }
   Int_t GetNumber() const { return fNumber; }
   ULong_t GetPixel() const;
   Float_t GetRed() const { return IsGrayscale() ? GetGrayscale() : fRed; }
   Float_t GetGreen() const { return IsGrayscale() ? GetGrayscale() : fGreen; }
   Float_t GetBlue() const { return IsGrayscale() ? GetGrayscale() : fBlue; }
   Float_t GetHue() const { return fHue; }
   Float_t GetLight() const { return fLight; }
   Float_t GetSaturation() const { return IsGrayscale() ? 0 : fSaturation; }
   Float_t GetAlpha() const { return fAlpha; }
   virtual Float_t GetGrayscale() const { /*ITU*/ return 0.299f*fRed + 0.587f*fGreen + 0.114f*fBlue; }
   virtual void ls(Option_t *option="") const;
   virtual void Print(Option_t *option="") const;
   virtual void SetAlpha(Float_t a) { fAlpha = a; }
   virtual void SetRGB(Float_t r, Float_t g, Float_t b);

   static void InitializeColors();
   static void HLS2RGB(Float_t h, Float_t l, Float_t s, Float_t &r, Float_t &g, Float_t &b);
   static void HLS2RGB(Int_t h, Int_t l, Int_t s, Int_t &r, Int_t &g, Int_t &b);
   static void HLStoRGB(Float_t h, Float_t l, Float_t s, Float_t &r, Float_t &g, Float_t &b)
                     { TColor::HLS2RGB(h, l, s, r, g, b); } // backward compatible
   static void HSV2RGB(Float_t h, Float_t s, Float_t v, Float_t &r, Float_t &g, Float_t &b);
   static void RGB2HLS(Float_t r, Float_t g, Float_t b, Float_t &h, Float_t &l, Float_t &s);
   static void RGB2HLS(Int_t r, Int_t g, Int_t b, Int_t &h, Int_t &l, Int_t &s);
   static void RGBtoHLS(Float_t r, Float_t g, Float_t b, Float_t &h, Float_t &l, Float_t &s)
                     { TColor::RGB2HLS(r, g, b, h, l, s); } // backward compatible
   static void RGB2HSV(Float_t r, Float_t g, Float_t b, Float_t &h, Float_t &s, Float_t &v);
   static Int_t GetColor(const char *hexcolor);
   static Int_t GetColor(Float_t r, Float_t g, Float_t b);
   static Int_t GetColor(Int_t r, Int_t g, Int_t b);
   static Int_t GetColor(ULong_t pixel);
   static Int_t GetColorBright(Int_t color);
   static Int_t GetColorDark(Int_t color);
   static ULong_t Number2Pixel(Int_t ci);
   static ULong_t RGB2Pixel(Int_t r, Int_t g, Int_t b);
   static ULong_t RGB2Pixel(Float_t r, Float_t g, Float_t b);
   static void Pixel2RGB(ULong_t pixel, Int_t &r, Int_t &g, Int_t &b);
   static void Pixel2RGB(ULong_t pixel, Float_t &r, Float_t &g, Float_t &b);
   static const char *PixelAsHexString(ULong_t pixel);
   static void SaveColor(ostream &out, Int_t ci);
   static Bool_t IsGrayscale();
   static void SetGrayscale(Bool_t set = kTRUE);
   static void SetPalette(Int_t ncolors, Int_t *colors);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TColor::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TColor::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TColor.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 127; } //Color defined by RGB or HLS
};
# 31 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TWbox.h" 2


class TWbox : public TBox {

protected:
   Short_t fBorderSize; //window box bordersize in pixels
   Short_t fBorderMode; //Bordermode (-1=down, 0 = no border, 1=up)

public:
   TWbox();
   TWbox(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2,
         Color_t color=18, Short_t bordersize=5 ,Short_t bordermode=1);
   TWbox(const TWbox &wbox);
   virtual ~TWbox();

   void Copy(TObject &wbox) const;
   virtual void Draw(Option_t *option="");
   virtual void DrawWbox(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2,
                      Color_t color=33 ,Short_t bordersize=5 ,Short_t bordermode=-1);
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   Short_t GetBorderMode() const { return fBorderMode;}
   Short_t GetBorderSize() const { return fBorderSize;}
   Int_t GetDarkColor() const {return TColor::GetColorDark(GetFillColor());}
   Int_t GetLightColor() const {return TColor::GetColorBright(GetFillColor());}
   virtual void Paint(Option_t *option="");
   virtual void PaintFrame(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2,
                            Color_t color, Short_t bordersize, Short_t bordermode,
                            Bool_t tops);
   virtual void PaintWbox(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2,
                 Color_t color=33, Short_t bordersize=5, Short_t bordermode=-1);
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetBorderMode(Short_t bordermode) {fBorderMode = bordermode;} // *MENU*
   virtual void SetBorderSize(Short_t bordersize) {fBorderSize = bordersize;} // *MENU*

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TWbox::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TWbox::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TWbox.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 65; } //A window box (box with 3-D effects)
};
# 21 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TROOT.h" 1
// @(#)root/base:$Id: TROOT.h 42030 2011-11-15 22:23:12Z pcanal $
// Author: Rene Brun   08/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TROOT                                                                //
//                                                                      //
// The TROOT object is the entry point to the system.                   //
// The single instance of TROOT is accessable via the global gROOT.     //
// Using the gROOT pointer one has access to basically every object     //
// created in a ROOT based program. The TROOT object is essentially a   //
// "dispatcher" with several lists pointing to the ROOT main objects.   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 35 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TROOT.h"
class TClass;
class TCanvas;
class TColor;
class TDataType;
class TFile;
class TStyle;
class TVirtualPad;
class TApplication;
class TInterpreter;
class TBrowser;
class TGlobal;
class TFunction;
class TFolder;
class TPluginManager;
class TProcessUUID;
class TClassGenerator;
class TVirtualMutex;



extern TVirtualMutex *gROOTMutex;

class TROOT : public TDirectory {

friend class TCint;
friend class TCintWithCling;

private:
   Int_t fLineIsProcessing; //To synchronize multi-threads

   static Int_t fgDirLevel; //Indentation level for ls()
   static Bool_t fgRootInit; //Singleton initialization flag
   static Bool_t fgMemCheck; //Turn on memory leak checker

   TROOT(const TROOT&); //Not implemented
   TROOT& operator=(const TROOT&); //Not implemented

protected:
   TString fConfigOptions; //ROOT ./configure set build options
   TString fConfigFeatures; //ROOT ./configure detected build features
   TString fVersion; //ROOT version (from CMZ VERSQQ) ex 0.05/01
   Int_t fVersionInt; //ROOT version in integer format (501)
   Int_t fVersionCode; //ROOT version code as used in RVersion.h
   Int_t fVersionDate; //Date of ROOT version (ex 951226)
   Int_t fVersionTime; //Time of ROOT version (ex 1152)
   Int_t fBuiltDate; //Date of ROOT built
   Int_t fBuiltTime; //Time of ROOT built
   Int_t fSvnRevision; //Subversion revision number of built
   TString fSvnBranch; //Subversion branch
   TString fSvnDate; //Date and time when make was run
   Int_t fTimer; //Timer flag
   TApplication *fApplication; //Pointer to current application
   TInterpreter *fInterpreter; //Command interpreter
   Bool_t fBatch; //True if session without graphics
   Bool_t fEditHistograms; //True if histograms can be edited with the mouse
   Bool_t fFromPopUp; //True if command executed from a popup menu
   Bool_t fMustClean; //True if object destructor scans canvases
   Bool_t fReadingObject; //True while reading an object [Deprecated (will be removed in next release)
   Bool_t fForceStyle; //Force setting of current style when reading objects
   Bool_t fInterrupt; //True if macro should be interrupted
   Bool_t fEscape; //True if ESC has been pressed
   Bool_t fExecutingMacro; //True while executing a TMacro
   Int_t fEditorMode; //Current Editor mode
   const TObject *fPrimitive; //Currently selected primitive
   TVirtualPad *fSelectPad; //Currently selected pad
   TCollection *fClasses; //List of classes definition
   TCollection *fTypes; //List of data types definition
   TCollection *fGlobals; //List of global variables
   TCollection *fGlobalFunctions; //List of global functions
   TSeqCollection *fClosedObjects; //List of closed objects from the list of files and sockets, so we can delete them if neededCl. 
   TSeqCollection *fFiles; //List of files
   TSeqCollection *fMappedFiles; //List of memory mapped files
   TSeqCollection *fSockets; //List of network sockets
   TSeqCollection *fCanvases; //List of canvases
   TSeqCollection *fStyles; //List of styles
   TCollection *fFunctions; //List of analytic functions
   TSeqCollection *fTasks; //List of tasks
   TSeqCollection *fColors; //List of colors
   TSeqCollection *fGeometries; //List of geometries
   TSeqCollection *fBrowsers; //List of browsers
   TSeqCollection *fSpecials; //List of special objects
   TSeqCollection *fCleanups; //List of recursiveRemove collections
   TSeqCollection *fMessageHandlers; //List of message handlers
   TSeqCollection *fStreamerInfo; //List of active StreamerInfo classes
   TCollection *fClassGenerators; //List of user defined class generators;
   TSeqCollection *fSecContexts; //List of security contexts (TSecContext)
   TSeqCollection *fProofs; //List of proof sessions
   TSeqCollection *fClipboard; //List of clipbard objects
   TSeqCollection *fDataSets; //List of data sets (TDSet or TChain)
   TProcessUUID *fUUIDs; //Pointer to TProcessID managing TUUIDs
   TFolder *fRootFolder; //top level folder //root
   TList *fBrowsables; //List of browsables
   TPluginManager *fPluginManager; //Keeps track of plugin library handlers
   TString fCutClassName; //Name of default CutG class in graphics editor
   TString fDefCanvasName; //Name of default canvas

                  TROOT(); //Only used by Dictionary
   void InitSystem(); //Operating System interface
   void InitThreads(); //Initialize threads library
   void ReadSvnInfo(); //Read Subversion revision number and branch name
   void *operator new(size_t l) { return TObject::operator new(l); }

public:
                     TROOT(const char *name, const char *title, VoidFuncPtr_t *initfunc = 0);
   virtual ~TROOT();
   void AddClass(TClass *cl);
   void AddClassGenerator(TClassGenerator *gen);
   void Browse(TBrowser *b);
   Bool_t ClassSaved(TClass *cl);
   void CloseFiles();
   virtual TObject *FindObject(const char *name) const;
   virtual TObject *FindObject(const TObject *obj) const;
   virtual TObject *FindObjectAny(const char *name) const;
   virtual TObject *FindObjectAnyFile(const char *name) const;
   TObject *FindSpecialObject(const char *name, void *&where);
   const char *FindObjectClassName(const char *name) const;
   const char *FindObjectPathName(const TObject *obj) const;
   TClass *FindSTLClass(const char *name, Bool_t load, Bool_t silent = kFALSE) const;
   void ForceStyle(Bool_t force = kTRUE) { fForceStyle = force; }
   Bool_t FromPopUp() const { return fFromPopUp; }
   TPluginManager *GetPluginManager() const { return fPluginManager; }
   TApplication *GetApplication() const { return fApplication; }
   TInterpreter *GetInterpreter() const { return fInterpreter; }
   TClass *GetClass(const char *name, Bool_t load = kTRUE, Bool_t silent = kFALSE) const;
   TClass *GetClass(const type_info &typeinfo, Bool_t load = kTRUE, Bool_t silent = kFALSE) const;
   TColor *GetColor(Int_t color) const;
   const char *GetConfigOptions() const { return fConfigOptions; }
   const char *GetConfigFeatures() const { return fConfigFeatures; }
   const char *GetCutClassName() const { return fCutClassName; }
   const char *GetDefCanvasName() const { return fDefCanvasName; }
   Bool_t GetEditHistograms() const { return fEditHistograms; }
   Int_t GetEditorMode() const { return fEditorMode; }
   Bool_t GetForceStyle() const { return fForceStyle; }
   Int_t GetBuiltDate() const { return fBuiltDate; }
   Int_t GetBuiltTime() const { return fBuiltTime; }
   Int_t GetSvnRevision() const { return fSvnRevision; }
   const char *GetSvnBranch() const { return fSvnBranch; }
   const char *GetSvnDate();
   Int_t GetVersionDate() const { return fVersionDate; }
   Int_t GetVersionTime() const { return fVersionTime; }
   Int_t GetVersionInt() const { return fVersionInt; }
   Int_t GetVersionCode() const { return fVersionCode; }
   const char *GetVersion() const { return fVersion; }
   TCollection *GetListOfClasses() const { return fClasses; }
   TSeqCollection *GetListOfColors() const { return fColors; }
   TCollection *GetListOfTypes(Bool_t load = kFALSE);
   TCollection *GetListOfGlobals(Bool_t load = kFALSE);
   TCollection *GetListOfGlobalFunctions(Bool_t load = kFALSE);
   TSeqCollection *GetListOfClosedObjects() const { return fClosedObjects; }
   TSeqCollection *GetListOfFiles() const { return fFiles; }
   TSeqCollection *GetListOfMappedFiles() const { return fMappedFiles; }
   TSeqCollection *GetListOfSockets() const { return fSockets; }
   TSeqCollection *GetListOfCanvases() const { return fCanvases; }
   TSeqCollection *GetListOfStyles() const { return fStyles; }
   TCollection *GetListOfFunctions() const { return fFunctions; }
   TSeqCollection *GetListOfGeometries() const { return fGeometries; }
   TSeqCollection *GetListOfBrowsers() const { return fBrowsers; }
   TSeqCollection *GetListOfSpecials() const { return fSpecials; }
   TSeqCollection *GetListOfTasks() const { return fTasks; }
   TSeqCollection *GetListOfCleanups() const { return fCleanups; }
   TSeqCollection *GetListOfStreamerInfo() const { return fStreamerInfo; }
   TSeqCollection *GetListOfMessageHandlers() const { return fMessageHandlers; }
   TCollection *GetListOfClassGenerators() const { return fClassGenerators; }
   TSeqCollection *GetListOfSecContexts() const { return fSecContexts; }
   TSeqCollection *GetListOfProofs() const { return fProofs; }
   TSeqCollection *GetClipboard() const { return fClipboard; }
   TSeqCollection *GetListOfDataSets() const { return fDataSets; }
   TList *GetListOfBrowsables() const { return fBrowsables; }
   TDataType *GetType(const char *name, Bool_t load = kFALSE) const;
   TFile *GetFile() const { if (gDirectory != this) return gDirectory->GetFile(); else return 0;}
   TFile *GetFile(const char *name) const;
   TStyle *GetStyle(const char *name) const;
   TObject *GetFunction(const char *name) const;
   TGlobal *GetGlobal(const char *name, Bool_t load = kFALSE) const;
   TGlobal *GetGlobal(const TObject *obj, Bool_t load = kFALSE) const;
   TFunction *GetGlobalFunction(const char *name, const char *params = 0, Bool_t load = kFALSE);
   TFunction *GetGlobalFunctionWithPrototype(const char *name, const char *proto = 0, Bool_t load = kFALSE);
   TObject *GetGeometry(const char *name) const;
   const TObject *GetSelectedPrimitive() const { return fPrimitive; }
   TVirtualPad *GetSelectedPad() const { return fSelectPad; }
   Int_t GetNclasses() const { return fClasses->GetSize(); }
   Int_t GetNtypes() const { return fTypes->GetSize(); }
   TFolder *GetRootFolder() const { return fRootFolder; }
   TProcessUUID *GetUUIDs() const { return fUUIDs; }
   void Idle(UInt_t idleTimeInSec, const char *command = 0);
   Int_t IgnoreInclude(const char *fname, const char *expandedfname);
   Bool_t IsBatch() const { return fBatch; }
   Bool_t IsExecutingMacro() const { return fExecutingMacro; }
   Bool_t IsFolder() const { return kTRUE; }
   Bool_t IsInterrupted() const { return fInterrupt; }
   Bool_t IsEscaped() const { return fEscape; }
   Bool_t IsLineProcessing() const { return fLineIsProcessing ? kTRUE : kFALSE; }
   Bool_t IsProofServ() const { return fName == "proofserv" ? kTRUE : kFALSE; }
   void ls(Option_t *option = "") const;
   Int_t LoadClass(const char *classname, const char *libname, Bool_t check = kFALSE);
   TClass *LoadClass(const char *name, Bool_t silent = kFALSE) const;
   Int_t LoadMacro(const char *filename, Int_t *error = 0, Bool_t check = kFALSE);
   Long_t Macro(const char *filename, Int_t *error = 0, Bool_t padUpdate = kTRUE);
   TCanvas *MakeDefCanvas() const;
   void Message(Int_t id, const TObject *obj);
   Bool_t MustClean() const { return fMustClean; }
   Long_t ProcessLine(const char *line, Int_t *error = 0);
   Long_t ProcessLineSync(const char *line, Int_t *error = 0);
   Long_t ProcessLineFast(const char *line, Int_t *error = 0);
   Bool_t ReadingObject() const { /* Deprecated (will be removed in next release) */ return fReadingObject; }
   void RefreshBrowsers();
   void RemoveClass(TClass *);
   void Reset(Option_t *option="");
   void SaveContext();
   void SetApplication(TApplication *app) { fApplication = app; }
   void SetBatch(Bool_t batch = kTRUE) { fBatch = batch; }
   void SetCutClassName(const char *name = "TCutG");
   void SetDefCanvasName(const char *name = "c1") { fDefCanvasName = name; }
   void SetEditHistograms(Bool_t flag = kTRUE) { fEditHistograms = flag; }
   void SetEditorMode(const char *mode = "");
   void SetExecutingMacro(Bool_t flag = kTRUE) { fExecutingMacro = flag; }
   void SetFromPopUp(Bool_t flag = kTRUE) { fFromPopUp = flag; }
   void SetInterrupt(Bool_t flag = kTRUE) { fInterrupt = flag; }
   void SetEscape(Bool_t flag = kTRUE) { fEscape = flag; }
   void SetLineIsProcessing() { fLineIsProcessing++; }
   void SetLineHasBeenProcessed() { if (fLineIsProcessing) fLineIsProcessing--; }
   void SetReadingObject(Bool_t flag = kTRUE) { fReadingObject = flag; }
   void SetMustClean(Bool_t flag = kTRUE) { fMustClean=flag; }
   void SetSelectedPrimitive(const TObject *obj) { fPrimitive = obj; }
   void SetSelectedPad(TVirtualPad *pad) { fSelectPad = pad; }
   void SetStyle(const char *stylename = "Default");
   void Time(Int_t casetime=1) { fTimer = casetime; }
   Int_t Timer() const { return fTimer; }

   //---- static functions
   static Int_t DecreaseDirLevel();
   static Int_t GetDirLevel();
   static const char *GetMacroPath();
   static void SetMacroPath(const char *newpath);
   static Int_t IncreaseDirLevel();
   static void IndentLevel();
   static Bool_t Initialized();
   static Bool_t MemCheck();
   static void SetDirLevel(Int_t level = 0);
   static Int_t ConvertVersionCode2Int(Int_t code);
   static Int_t ConvertVersionInt2Code(Int_t v);
   static Int_t RootVersionCode();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TROOT::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TROOT::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TROOT.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 278; } //Top level (or root) structure for all classes
};


extern TROOT *gROOT;
namespace ROOT {
   TROOT *GetROOT();
}
# 22 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TButton.h" 1
// @(#)root/gpad:$Id: TButton.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   01/07/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TButton                                                              //
//                                                                      //
//  A TButton object is a specialized TPad including possible list
//  of primitives used to build selections and options menus in a canvas.
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 32 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TButton.h"
class TButton : public TPad, public TAttText {

private:
   Bool_t fFocused; // If cursor is in...
   Bool_t fFraming; // True if you want a frame to be painted when pressed

   TButton(const TButton &org); // no copy ctor, use TObject::Clone()
   TButton &operator=(const TButton &rhs); // idem

protected:
   TString fMethod; //Method to be executed by this button

public:
   TButton();
   TButton(const char *title, const char *method, Double_t x1, Double_t y1, Double_t x2, Double_t y2);
   virtual ~TButton();
   virtual void Divide(Int_t nx=1, Int_t ny=1, Float_t xmargin=0.01, Float_t ymargin=0.01, Int_t color=0);
   virtual void Draw(Option_t *option="");
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   virtual const char *GetMethod() const { return fMethod.Data(); }
   virtual void Paint(Option_t *option="");
   virtual void PaintModified();
   virtual void Range(Double_t x1, Double_t y1, Double_t x2, Double_t y2);
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetBorderMode(Short_t bordermode) { fBorderMode = bordermode; }
   virtual void SetFraming(Bool_t f=1);
   virtual Bool_t GetFraming() { return fFraming; };
   virtual void SetGrid(Int_t valuex = 1, Int_t valuey = 1);
   virtual void SetLogx(Int_t value = 1);
   virtual void SetLogy(Int_t value = 1);
   virtual void SetMethod(const char *method) { fMethod=method; } // *MENU*
   virtual void SetName(const char *name) { fName = name; }
   virtual void x3d(Option_t *option="");

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TButton::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TButton::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TButton.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 66; } //A user interface button.
};

inline void TButton::Divide(Int_t, Int_t, Float_t, Float_t, Int_t) { }
inline void TButton::SetGrid(Int_t, Int_t) { }
inline void TButton::SetLogx(Int_t) { }
inline void TButton::SetLogy(Int_t) { }
inline void TButton::x3d(Option_t *) { }
# 23 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TColor.h" 1
// @(#)root/base:$Id: TColor.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 24 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraphErrors.h" 1
// @(#)root/hist:$Id: TGraphErrors.h 24702 2008-07-08 12:01:46Z brun $
// Author: Rene Brun   15/09/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGraphErrors                                                         //
//                                                                      //
// a Graph with error bars                                              //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TGraphErrors : public TGraph {

protected:
   Double_t *fEX; //[fNpoints] array of X errors
   Double_t *fEY; //[fNpoints] array of Y errors

   virtual void SwapPoints(Int_t pos1, Int_t pos2);

   virtual Double_t** Allocate(Int_t size);
   virtual void CopyAndRelease(Double_t **newarrays,
                                     Int_t ibegin, Int_t iend, Int_t obegin);
   virtual Bool_t CopyPoints(Double_t **arrays, Int_t ibegin, Int_t iend,
                                 Int_t obegin);
   Bool_t CtorAllocate();
   virtual void FillZero(Int_t begin, Int_t end,
                               Bool_t from_ctor = kTRUE);

public:
   TGraphErrors();
   TGraphErrors(Int_t n);
   TGraphErrors(Int_t n, const Float_t *x, const Float_t *y, const Float_t *ex=0, const Float_t *ey=0);
   TGraphErrors(Int_t n, const Double_t *x, const Double_t *y, const Double_t *ex=0, const Double_t *ey=0);
   TGraphErrors(const TVectorF &vx, const TVectorF &vy, const TVectorF &vex, const TVectorF &vey);
   TGraphErrors(const TVectorD &vx, const TVectorD &vy, const TVectorD &vex, const TVectorD &vey);
   TGraphErrors(const TGraphErrors &gr);
   TGraphErrors& operator=(const TGraphErrors &gr);
   TGraphErrors(const TH1 *h);
   TGraphErrors(const char *filename, const char *format="%lg %lg %lg %lg", Option_t *option="");
   virtual ~TGraphErrors();
   virtual void Apply(TF1 *f);
   static Int_t CalculateScanfFields(const char *fmt);
   virtual void ComputeRange(Double_t &xmin, Double_t &ymin, Double_t &xmax, Double_t &ymax) const;
   Double_t GetErrorX(Int_t bin) const;
   Double_t GetErrorY(Int_t bin) const;
   Double_t GetErrorXhigh(Int_t bin) const;
   Double_t GetErrorXlow(Int_t bin) const;
   Double_t GetErrorYhigh(Int_t bin) const;
   Double_t GetErrorYlow(Int_t bin) const;
   Double_t *GetEX() const {return fEX;}
   Double_t *GetEY() const {return fEY;}
   virtual void Print(Option_t *chopt="") const;
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetPointError(Double_t ex, Double_t ey); // *MENU
   virtual void SetPointError(Int_t i, Double_t ex, Double_t ey);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TGraphErrors::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TGraphErrors::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraphErrors.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 73; } //A graph with error bars
};

inline Double_t **TGraphErrors::Allocate(Int_t size) {
   return AllocateArrays(4, size);
}
# 25 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMarker.h" 1
// @(#)root/graf:$Id: TMarker.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/05/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMarker                                                              //
//                                                                      //
// Marker.                                                              //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 34 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMarker.h"
class TMarker : public TObject, public TAttMarker {

protected:
   Double_t fX; //X position of marker (left,center,etc..)
   Double_t fY; //Y position of marker (left,center,etc..)

public:
   // TMarker status bits
   enum { kMarkerNDC = (1ULL << (14)) };

   TMarker();
   TMarker(Double_t x, Double_t y, Int_t marker);
   TMarker(const TMarker &marker);
   virtual ~TMarker();

   void Copy(TObject &marker) const;
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual void Draw(Option_t *option="");
   virtual void DrawMarker(Double_t x, Double_t y);
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   Double_t GetX() const {return fX;}
   Double_t GetY() const {return fY;}
   virtual void ls(Option_t *option="") const;
   virtual void Paint(Option_t *option="");
   virtual void PaintMarker(Double_t x, Double_t y);
   virtual void PaintMarkerNDC(Double_t u, Double_t v);
   virtual void Print(Option_t *option="") const;
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetNDC(Bool_t isNDC=kTRUE);
   virtual void SetX(Double_t x) { fX = x;} // *MENU*
   virtual void SetY(Double_t y) { fY = y;} // *MENU*

   static void DisplayMarkerTypes();

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TMarker::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TMarker::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMarker.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 68; } //Marker
};
# 26 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h" 1
// @(#)root/mathcore:$Id: TMath.h 41837 2011-11-09 16:04:19Z rdm $
// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMath                                                                //
//                                                                      //
// Encapsulate most frequently used Math functions.                     //
// NB. The basic functions Min, Max, Abs and Sign are defined           //
// in TMathBase.                                                        //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 33 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h"
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TError.h" 1
// @(#)root/base:$Id: TError.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Error handling routines.                                             //
//                                                                      //
// This file defines a number of global error handling routines:        //
// Warning(), Error(), SysError() and Fatal(). They all take a          //
// location string (where the error happened) and a printf style format //
// string plus vararg's. In the end these functions call an             //
// errorhanlder function. By default DefaultErrorHandler() is used.     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/stdarg.h" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
/****************************************************************
* stdarg.h
*****************************************************************/
# 33 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TError.h" 2


class TVirtualMutex;

const Int_t kUnset = -1;
const Int_t kPrint = 0;
const Int_t kInfo = 1000;
const Int_t kWarning = 2000;
const Int_t kError = 3000;
const Int_t kBreak = 4000;
const Int_t kSysError = 5000;
const Int_t kFatal = 6000;

extern TVirtualMutex *gErrorMutex;

typedef void (*ErrorHandlerFunc_t)(int level, Bool_t abort, const char *location,
              const char *msg);

extern "C" void ErrorHandler(int level, const char *location, const char *fmt,
                             va_list va);

extern void DefaultErrorHandler(int level, Bool_t abort, const char *location,
                                const char *msg);

extern ErrorHandlerFunc_t SetErrorHandler(ErrorHandlerFunc_t newhandler);
extern ErrorHandlerFunc_t GetErrorHandler();

extern void Info(const char *location, const char *msgfmt, ...)



;
extern void Warning(const char *location, const char *msgfmt, ...)



;
extern void Error(const char *location, const char *msgfmt, ...)



;
extern void Break(const char *location, const char *msgfmt, ...)



;
extern void SysError(const char *location, const char *msgfmt, ...)



;
extern void Fatal(const char *location, const char *msgfmt, ...)



;

extern void AbstractMethod(const char *method);
extern void MayNotUse(const char *method);
extern void Obsolete(const char *function, const char *asOfVers, const char *removedFromVers);

extern const char *kAssertMsg;
extern const char *kCheckMsg;
# 107 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TError.h"
extern Int_t gErrorIgnoreLevel;
extern Int_t gErrorAbortLevel;
extern Bool_t gPrintViaErrorHandler;
# 34 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/algorithm" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_algorithm" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <algorithm.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/algorithm" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/algorithm

#pragma ifndef PREC_STL_ALGORITHM
#pragma define PREC_STL_ALGORITHM
#pragma link off global PREC_STL_ALGORITHM;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

template <class BidirectionalIterator>
inline void reverse(BidirectionalIterator first, BidirectionalIterator last) {}

// Generic algorithms can not be precompiled

#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_algorithm" 2
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/algorithm" 2
}
# 35 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/limits" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/limits" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/limits

#pragma ifndef PREC_STL_LIMITS
#pragma define PREC_STL_LIMITS
#pragma link off global PREC_STL_LIMITS;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

// to be implemented

#pragma endif
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/limits" 2
# 36 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/cmath" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {

#pragma include_noerr <stdcxxfunc.dll>
}
# 37 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h" 2

namespace TMath {

   /* ************************* */
   /* * Fundamental constants * */
   /* ************************* */

   inline Double_t Pi() { return 3.14159265358979323846; }
   inline Double_t TwoPi() { return 2.0 * Pi(); }
   inline Double_t PiOver2() { return Pi() / 2.0; }
   inline Double_t PiOver4() { return Pi() / 4.0; }
   inline Double_t InvPi() { return 1.0 / Pi(); }
   inline Double_t RadToDeg() { return 180.0 / Pi(); }
   inline Double_t DegToRad() { return Pi() / 180.0; }
   inline Double_t Sqrt2() { return 1.4142135623730950488016887242097; }

   // e (base of natural log)
   inline Double_t E() { return 2.71828182845904523536; }

   // natural log of 10 (to convert log to ln)
   inline Double_t Ln10() { return 2.30258509299404568402; }

   // base-10 log of e  (to convert ln to log)
   inline Double_t LogE() { return 0.43429448190325182765; }

   // velocity of light
   inline Double_t C() { return 2.99792458e8; } // m s^-1
   inline Double_t Ccgs() { return 100.0 * C(); } // cm s^-1
   inline Double_t CUncertainty() { return 0.0; } // exact

   // gravitational constant
   inline Double_t G() { return 6.673e-11; } // m^3 kg^-1 s^-2
   inline Double_t Gcgs() { return G() / 1000.0; } // cm^3 g^-1 s^-2
   inline Double_t GUncertainty() { return 0.010e-11; }

   // G over h-bar C
   inline Double_t GhbarC() { return 6.707e-39; } // (GeV/c^2)^-2
   inline Double_t GhbarCUncertainty() { return 0.010e-39; }

   // standard acceleration of gravity
   inline Double_t Gn() { return 9.80665; } // m s^-2
   inline Double_t GnUncertainty() { return 0.0; } // exact

   // Planck's constant
   inline Double_t H() { return 6.62606876e-34; } // J s
   inline Double_t Hcgs() { return 1.0e7 * H(); } // erg s
   inline Double_t HUncertainty() { return 0.00000052e-34; }

   // h-bar (h over 2 pi)
   inline Double_t Hbar() { return 1.054571596e-34; } // J s
   inline Double_t Hbarcgs() { return 1.0e7 * Hbar(); } // erg s
   inline Double_t HbarUncertainty() { return 0.000000082e-34; }

   // hc (h * c)
   inline Double_t HC() { return H() * C(); } // J m
   inline Double_t HCcgs() { return Hcgs() * Ccgs(); } // erg cm

   // Boltzmann's constant
   inline Double_t K() { return 1.3806503e-23; } // J K^-1
   inline Double_t Kcgs() { return 1.0e7 * K(); } // erg K^-1
   inline Double_t KUncertainty() { return 0.0000024e-23; }

   // Stefan-Boltzmann constant
   inline Double_t Sigma() { return 5.6704e-8; } // W m^-2 K^-4
   inline Double_t SigmaUncertainty() { return 0.000040e-8; }

   // Avogadro constant (Avogadro's Number)
   inline Double_t Na() { return 6.02214199e+23; } // mol^-1
   inline Double_t NaUncertainty() { return 0.00000047e+23; }

   // universal gas constant (Na * K)
   // http://scienceworld.wolfram.com/physics/UniversalGasConstant.html
   inline Double_t R() { return K() * Na(); } // J K^-1 mol^-1
   inline Double_t RUncertainty() { return R()*((KUncertainty()/K()) + (NaUncertainty()/Na())); }

   // Molecular weight of dry air
   // 1976 US Standard Atmosphere,
   // also see http://atmos.nmsu.edu/jsdap/encyclopediawork.html
   inline Double_t MWair() { return 28.9644; } // kg kmol^-1 (or gm mol^-1)

   // Dry Air Gas Constant (R / MWair)
   // http://atmos.nmsu.edu/education_and_outreach/encyclopedia/gas_constant.htm
   inline Double_t Rgair() { return (1000.0 * R()) / MWair(); } // J kg^-1 K^-1

   // Euler-Mascheroni Constant
   inline Double_t EulerGamma() { return 0.577215664901532860606512090082402431042; }

   // Elementary charge
   inline Double_t Qe() { return 1.602176462e-19; } // C
   inline Double_t QeUncertainty() { return 0.000000063e-19; }

   /* ************************** */
   /* * Mathematical Functions * */
   /* ************************** */

   /* ***************************** */
   /* * Trigonometrical Functions * */
   /* ***************************** */
   inline Double_t Sin(Double_t);
   inline Double_t Cos(Double_t);
   inline Double_t Tan(Double_t);
   inline Double_t SinH(Double_t);
   inline Double_t CosH(Double_t);
   inline Double_t TanH(Double_t);
   inline Double_t ASin(Double_t);
   inline Double_t ACos(Double_t);
   inline Double_t ATan(Double_t);
   inline Double_t ATan2(Double_t, Double_t);
          Double_t ASinH(Double_t);
          Double_t ACosH(Double_t);
          Double_t ATanH(Double_t);
          Double_t Hypot(Double_t x, Double_t y);


   /* ************************ */
   /* * Elementary Functions * */
   /* ************************ */
   inline Double_t Sqrt(Double_t x);
   inline Double_t Ceil(Double_t x);
   inline Int_t CeilNint(Double_t x);
   inline Double_t Floor(Double_t x);
   inline Int_t FloorNint(Double_t x);
   inline Double_t Exp(Double_t x);
   inline Double_t Ldexp(Double_t x, Int_t exp);
          Double_t Factorial(Int_t i);
   inline Double_t Power(Double_t x, Double_t y);
   inline Double_t Power(Double_t x, Int_t y);
   inline Double_t Log(Double_t x);
          Double_t Log2(Double_t x);
   inline Double_t Log10(Double_t x);
          Int_t Nint(Float_t x);
          Int_t Nint(Double_t x);
   inline Int_t Finite(Double_t x);
   inline Int_t IsNaN(Double_t x);

   inline Double_t QuietNaN();
   inline Double_t SignalingNaN();
   inline Double_t Infinity();

   template <typename T>
   struct Limits {
      inline static T Min();
      inline static T Max();
      inline static T Epsilon();
   };

   // Some integer math
   Long_t Hypot(Long_t x, Long_t y); // sqrt(px*px + py*py)

   // Comparing floating points
   inline Bool_t AreEqualAbs(Double_t af, Double_t bf, Double_t epsilon) {
      //return kTRUE if absolute difference between af and bf is less than epsilon
      return TMath::Abs(af-bf) < epsilon;
   }
   inline Bool_t AreEqualRel(Double_t af, Double_t bf, Double_t relPrec) {
      //return kTRUE if relative difference between af and bf is less than relPrec
      return TMath::Abs(af-bf) <= 0.5*relPrec*(TMath::Abs(af)+TMath::Abs(bf));
   }

   /* ******************** */
   /* * Array Algorithms * */
   /* ******************** */

   // Min, Max of an array
   template <typename T> T MinElement(Long64_t n, const T *a);
   template <typename T> T MaxElement(Long64_t n, const T *a);

   // Locate Min, Max element number in an array
   template <typename T> Long64_t LocMin(Long64_t n, const T *a);
   template <typename Iterator> Iterator LocMin(Iterator first, Iterator last);
   template <typename T> Long64_t LocMax(Long64_t n, const T *a);
   template <typename Iterator> Iterator LocMax(Iterator first, Iterator last);

   // Binary search
   template <typename T> Long64_t BinarySearch(Long64_t n, const T *array, T value);
   template <typename T> Long64_t BinarySearch(Long64_t n, const T **array, T value);
   template <typename Iterator, typename Element> Iterator BinarySearch(Iterator first, Iterator last, Element value);

   // Hashing
   ULong_t Hash(const void *txt, Int_t ntxt);
   ULong_t Hash(const char *str);

   // Sorting
   template <typename Element, typename Index>
   void Sort(Index n, const Element* a, Index* index, Bool_t down=kTRUE);
   template <typename Iterator, typename IndexIterator>
   void SortItr(Iterator first, Iterator last, IndexIterator index, Bool_t down=kTRUE);

   void BubbleHigh(Int_t Narr, Double_t *arr1, Int_t *arr2);
   void BubbleLow (Int_t Narr, Double_t *arr1, Int_t *arr2);

   Bool_t Permute(Int_t n, Int_t *a); // Find permutations

   /* ************************* */
   /* * Geometrical Functions * */
   /* ************************* */

   //Sample quantiles
   void Quantiles(Int_t n, Int_t nprob, Double_t *x, Double_t *quantiles, Double_t *prob,
                       Bool_t isSorted=kTRUE, Int_t *index = 0, Int_t type=7);

   // IsInside
   template <typename T> Bool_t IsInside(T xp, T yp, Int_t np, T *x, T *y);

   // Calculate the Cross Product of two vectors
   template <typename T> T *Cross(const T v1[3],const T v2[3], T out[3]);

   Float_t Normalize(Float_t v[3]); // Normalize a vector
   Double_t Normalize(Double_t v[3]); // Normalize a vector

   //Calculate the Normalized Cross Product of two vectors
   template <typename T> inline T NormCross(const T v1[3],const T v2[3],T out[3]);

   // Calculate a normal vector of a plane
   template <typename T> T *Normal2Plane(const T v1[3],const T v2[3],const T v3[3], T normal[3]);

   /* ************************ */
   /* * Polynomial Functions * */
   /* ************************ */

   Bool_t RootsCubic(const Double_t coef[4],Double_t &a, Double_t &b, Double_t &c);

   /* *********************** */
   /* * Statistic Functions * */
   /* *********************** */

   Double_t Binomial(Int_t n,Int_t k); // Calculate the binomial coefficient n over k
   Double_t BinomialI(Double_t p, Int_t n, Int_t k);
   Double_t BreitWigner(Double_t x, Double_t mean=0, Double_t gamma=1);
   Double_t CauchyDist(Double_t x, Double_t t=0, Double_t s=1);
   Double_t ChisquareQuantile(Double_t p, Double_t ndf);
   Double_t FDist(Double_t F, Double_t N, Double_t M);
   Double_t FDistI(Double_t F, Double_t N, Double_t M);
   Double_t Gaus(Double_t x, Double_t mean=0, Double_t sigma=1, Bool_t norm=kFALSE);
   Double_t KolmogorovProb(Double_t z);
   Double_t KolmogorovTest(Int_t na, const Double_t *a, Int_t nb, const Double_t *b, Option_t *option);
   Double_t Landau(Double_t x, Double_t mpv=0, Double_t sigma=1, Bool_t norm=kFALSE);
   Double_t LandauI(Double_t x);
   Double_t LaplaceDist(Double_t x, Double_t alpha=0, Double_t beta=1);
   Double_t LaplaceDistI(Double_t x, Double_t alpha=0, Double_t beta=1);
   Double_t LogNormal(Double_t x, Double_t sigma, Double_t theta=0, Double_t m=1);
   Double_t NormQuantile(Double_t p);
   Double_t Poisson(Double_t x, Double_t par);
   Double_t PoissonI(Double_t x, Double_t par);
   Double_t Prob(Double_t chi2,Int_t ndf);
   Double_t Student(Double_t T, Double_t ndf);
   Double_t StudentI(Double_t T, Double_t ndf);
   Double_t StudentQuantile(Double_t p, Double_t ndf, Bool_t lower_tail=kTRUE);
   Double_t Vavilov(Double_t x, Double_t kappa, Double_t beta2);
   Double_t VavilovI(Double_t x, Double_t kappa, Double_t beta2);
   Double_t Voigt(Double_t x, Double_t sigma, Double_t lg, Int_t r = 4);

   /* ************************** */
   /* * Statistics over arrays * */
   /* ************************** */

   //Mean, Geometric Mean, Median, RMS(sigma)

   template <typename T> Double_t Mean(Long64_t n, const T *a, const Double_t *w=0);
   template <typename Iterator> Double_t Mean(Iterator first, Iterator last);
   template <typename Iterator, typename WeightIterator> Double_t Mean(Iterator first, Iterator last, WeightIterator w);

   template <typename T> Double_t GeomMean(Long64_t n, const T *a);
   template <typename Iterator> Double_t GeomMean(Iterator first, Iterator last);

   template <typename T> Double_t RMS(Long64_t n, const T *a);
   template <typename Iterator> Double_t RMS(Iterator first, Iterator last);

   template <typename T> Double_t Median(Long64_t n, const T *a, const Double_t *w=0, Long64_t *work=0);

   //k-th order statistic
   template <class Element, typename Size> Element KOrdStat(Size n, const Element *a, Size k, Size *work = 0);

   /* ******************* */
   /* * Special Functions */
   /* ******************* */

   Double_t Beta(Double_t p, Double_t q);
   Double_t BetaCf(Double_t x, Double_t a, Double_t b);
   Double_t BetaDist(Double_t x, Double_t p, Double_t q);
   Double_t BetaDistI(Double_t x, Double_t p, Double_t q);
   Double_t BetaIncomplete(Double_t x, Double_t a, Double_t b);

   // Bessel functions
   Double_t BesselI(Int_t n,Double_t x); // integer order modified Bessel function I_n(x)
   Double_t BesselK(Int_t n,Double_t x); // integer order modified Bessel function K_n(x)
   Double_t BesselI0(Double_t x); // modified Bessel function I_0(x)
   Double_t BesselK0(Double_t x); // modified Bessel function K_0(x)
   Double_t BesselI1(Double_t x); // modified Bessel function I_1(x)
   Double_t BesselK1(Double_t x); // modified Bessel function K_1(x)
   Double_t BesselJ0(Double_t x); // Bessel function J0(x) for any real x
   Double_t BesselJ1(Double_t x); // Bessel function J1(x) for any real x
   Double_t BesselY0(Double_t x); // Bessel function Y0(x) for positive x
   Double_t BesselY1(Double_t x); // Bessel function Y1(x) for positive x
   Double_t StruveH0(Double_t x); // Struve functions of order 0
   Double_t StruveH1(Double_t x); // Struve functions of order 1
   Double_t StruveL0(Double_t x); // Modified Struve functions of order 0
   Double_t StruveL1(Double_t x); // Modified Struve functions of order 1

   Double_t DiLog(Double_t x);
   Double_t Erf(Double_t x);
   Double_t ErfInverse(Double_t x);
   Double_t Erfc(Double_t x);
   Double_t ErfcInverse(Double_t x);
   Double_t Freq(Double_t x);
   Double_t Gamma(Double_t z);
   Double_t Gamma(Double_t a,Double_t x);
   Double_t GammaDist(Double_t x, Double_t gamma, Double_t mu=0, Double_t beta=1);
   Double_t LnGamma(Double_t z);
}


//---- Trig and other functions ------------------------------------------------
# 362 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h"
// math functions are defined inline so we have to include them here




// #   if defined(R__GLIBC) && defined(__STRICT_ANSI__)
// #      ifndef finite
// #         define finite __finite
// #      endif
// #      ifndef isnan
// #         define isnan  __isnan
// #      endif
// #   endif
# 411 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h"
inline Double_t TMath::Sin(Double_t x)
   { return sin(x); }

inline Double_t TMath::Cos(Double_t x)
   { return cos(x); }

inline Double_t TMath::Tan(Double_t x)
   { return tan(x); }

inline Double_t TMath::SinH(Double_t x)
   { return sinh(x); }

inline Double_t TMath::CosH(Double_t x)
   { return cosh(x); }

inline Double_t TMath::TanH(Double_t x)
   { return tanh(x); }

inline Double_t TMath::ASin(Double_t x)
   { if (x < -1.) return -TMath::Pi()/2;
     if (x > 1.) return TMath::Pi()/2;
     return asin(x);
   }

inline Double_t TMath::ACos(Double_t x)
   { if (x < -1.) return TMath::Pi();
     if (x > 1.) return 0;
     return acos(x);
   }

inline Double_t TMath::ATan(Double_t x)
   { return atan(x); }

inline Double_t TMath::ATan2(Double_t y, Double_t x)
   { if (x != 0) return atan2(y, x);
     if (y == 0) return 0;
     if (y > 0) return Pi()/2;
     else return -Pi()/2;
   }

inline Double_t TMath::Sqrt(Double_t x)
   { return sqrt(x); }

inline Double_t TMath::Ceil(Double_t x)
   { return ceil(x); }

inline Int_t TMath::CeilNint(Double_t x)
   { return TMath::Nint(ceil(x)); }

inline Double_t TMath::Floor(Double_t x)
   { return floor(x); }

inline Int_t TMath::FloorNint(Double_t x)
   { return TMath::Nint(floor(x)); }

inline Double_t TMath::Exp(Double_t x)
   { return exp(x); }

inline Double_t TMath::Ldexp(Double_t x, Int_t exp)
   { return ldexp(x, exp); }

inline Double_t TMath::Power(Double_t x, Double_t y)
   { return pow(x, y); }

inline Double_t TMath::Power(Double_t x, Int_t y) {

   return std::pow(x, y);



}

inline Double_t TMath::Log(Double_t x)
   { return log(x); }

inline Double_t TMath::Log10(Double_t x)
   { return log10(x); }

inline Int_t TMath::Finite(Double_t x)
# 501 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h"
   { return finite(x); }


inline Int_t TMath::IsNaN(Double_t x)





   // from cmath
   { return std::isnan(x); }





//--------wrapper to numeric_limits
//____________________________________________________________________________
inline Double_t TMath::QuietNaN() {
   // returns a quiet NaN as defined by IEEE 754 
   // see http://en.wikipedia.org/wiki/NaN#Quiet_NaN
   return std::numeric_limits<Double_t>::quiet_NaN();
}

//____________________________________________________________________________
inline Double_t TMath::SignalingNaN() {
   // returns a signaling NaN as defined by IEEE 754 
   // see http://en.wikipedia.org/wiki/NaN#Signaling_NaN
   return std::numeric_limits<Double_t>::signaling_NaN();
}

inline Double_t TMath::Infinity() {
   // returns an infinity as defined by the IEEE standard
   return std::numeric_limits<Double_t>::infinity();
}

template<typename T>
inline T TMath::Limits<T>::Min() {
   // returns maximum representation for type T
   return (std::numeric_limits<T>::min)(); //N.B. use this signature to avoid class with macro min() on Windows 
}

template<typename T>
inline T TMath::Limits<T>::Max() {
   // returns minimum double representation
   return (std::numeric_limits<T>::max)(); //N.B. use this signature to avoid class with macro max() on Windows 
}

template<typename T>
inline T TMath::Limits<T>::Epsilon() {
   // returns minimum double representation
   return std::numeric_limits<T>::epsilon();
}


//-------- Advanced -------------

template <typename T> inline T TMath::NormCross(const T v1[3],const T v2[3],T out[3])
{
   // Calculate the Normalized Cross Product of two vectors
   return Normalize(Cross(v1,v2,out));
}

template <typename T>
T TMath::MinElement(Long64_t n, const T *a) {
   // Return minimum of array a of length n.

   return *std::min_element(a,a+n);
}

template <typename T>
T TMath::MaxElement(Long64_t n, const T *a) {
   // Return maximum of array a of length n.

   return *std::max_element(a,a+n);
}

template <typename T>
Long64_t TMath::LocMin(Long64_t n, const T *a) {
   // Return index of array with the minimum element.
   // If more than one element is minimum returns first found.

   // Implement here since this one is found to be faster (mainly on 64 bit machines)
   // than stl generic implementation.
   // When performing the comparison,  the STL implementation needs to de-reference both the array iterator
   // and the iterator pointing to the resulting minimum location

   if (n <= 0 || !a) return -1;
   T xmin = a[0];
   Long64_t loc = 0;
   for (Long64_t i = 1; i < n; i++) {
      if (xmin > a[i]) {
         xmin = a[i];
         loc = i;
      }
   }
   return loc;
}

template <typename Iterator>
Iterator TMath::LocMin(Iterator first, Iterator last) {
   // Return index of array with the minimum element.
   // If more than one element is minimum returns first found.
   return std::min_element(first, last);
}

template <typename T>
Long64_t TMath::LocMax(Long64_t n, const T *a) {
   // Return index of array with the maximum element.
   // If more than one element is maximum returns first found.

   // Implement here since it is faster (see comment in LocMin function)

   if (n <= 0 || !a) return -1;
   T xmax = a[0];
   Long64_t loc = 0;
   for (Long64_t i = 1; i < n; i++) {
      if (xmax < a[i]) {
         xmax = a[i];
         loc = i;
      }
   }
   return loc;
}

template <typename Iterator>
Iterator TMath::LocMax(Iterator first, Iterator last)
{
   // Return index of array with the maximum element.
   // If more than one element is maximum returns first found.

   return std::max_element(first, last);
}

template<typename T>
struct CompareDesc {

   CompareDesc(T d) : fData(d) {}

   template<typename Index>
   bool operator()(Index i1, Index i2) {
      return *(fData + i1) > *(fData + i2);
   }

   T fData;
};

template<typename T>
struct CompareAsc {

   CompareAsc(T d) : fData(d) {}

   template<typename Index>
   bool operator()(Index i1, Index i2) {
      return *(fData + i1) < *(fData + i2);
   }

   T fData;
};

template <typename Iterator>
Double_t TMath::Mean(Iterator first, Iterator last)
{
   // Return the weighted mean of an array defined by the iterators.

   Double_t sum = 0;
   Double_t sumw = 0;
   while ( first != last )
   {
      sum += *first;
      sumw += 1;
      first++;
   }

   return sum/sumw;
}

template <typename Iterator, typename WeightIterator>
Double_t TMath::Mean(Iterator first, Iterator last, WeightIterator w)
{
   // Return the weighted mean of an array defined by the first and
   // last iterators. The w iterator should point to the first element
   // of a vector of weights of the same size as the main array.

   Double_t sum = 0;
   Double_t sumw = 0;
   int i = 0;
   while ( first != last ) {
      if ( *w < 0) {
         ::Error("TMath::Mean","w[%d] = %.4e < 0 ?!",i,*w);
         return 0;
      }
      sum += (*w) * (*first);
      sumw += (*w) ;
      ++w;
      ++first;
      ++i;
   }
   if (sumw <= 0) {
      ::Error("TMath::Mean","sum of weights == 0 ?!");
      return 0;
   }

   return sum/sumw;
}

template <typename T>
Double_t TMath::Mean(Long64_t n, const T *a, const Double_t *w)
{
   // Return the weighted mean of an array a with length n.

   if (w) {
      return TMath::Mean(a, a+n, w);
   } else {
      return TMath::Mean(a, a+n);
   }
}

template <typename Iterator>
Double_t TMath::GeomMean(Iterator first, Iterator last)
{
   // Return the geometric mean of an array defined by the iterators.
   // geometric_mean = (Prod_i=0,n-1 |a[i]|)^1/n

   Double_t logsum = 0.;
   Long64_t n = 0;
   while ( first != last ) {
      if (*first == 0) return 0.;
      Double_t absa = (Double_t) TMath::Abs(*first);
      logsum += TMath::Log(absa);
      ++first;
      ++n;
   }

   return TMath::Exp(logsum/n);
}

template <typename T>
Double_t TMath::GeomMean(Long64_t n, const T *a)
{
   // Return the geometric mean of an array a of size n.
   // geometric_mean = (Prod_i=0,n-1 |a[i]|)^1/n

   return TMath::GeomMean(a, a+n);
}

template <typename Iterator>
Double_t TMath::RMS(Iterator first, Iterator last)
{
   // Return the Standard Deviation of an array defined by the iterators.
   // Note that this function returns the sigma(standard deviation) and
   // not the root mean square of the array.

   Double_t n = 0;

   Double_t tot = 0, tot2 =0, adouble;
   while ( first != last ) {
      adouble=Double_t(*first);
      tot += adouble; tot2 += adouble*adouble;
      ++first;
      ++n;
   }
   Double_t n1 = 1./n;
   Double_t mean = tot*n1;
   Double_t rms = TMath::Sqrt(TMath::Abs(tot2*n1 -mean*mean));
   return rms;
}

template <typename T>
Double_t TMath::RMS(Long64_t n, const T *a)
{
   // Return the Standard Deviation of an array a with length n.
   // Note that this function returns the sigma(standard deviation) and
   // not the root mean square of the array.

   return TMath::RMS(a, a+n);
}

template <typename Iterator, typename Element>
Iterator TMath::BinarySearch(Iterator first, Iterator last, Element value)
{
   // Binary search in an array defined by its iterators.
   //
   // The values in the iterators range are supposed to be sorted
   // prior to this call.  If match is found, function returns
   // position of element.  If no match found, function gives nearest
   // element smaller than value.

   Iterator pind;
   pind = std::lower_bound(first, last, value);
   if ( (pind != last) && (*pind == value) )
      return pind;
   else
      return ( pind - 1);
}


template <typename T> Long64_t TMath::BinarySearch(Long64_t n, const T *array, T value)
{
   // Binary search in an array of n values to locate value.
   //
   // Array is supposed  to be sorted prior to this call.
   // If match is found, function returns position of element.
   // If no match found, function gives nearest element smaller than value.

   const T* pind;
   pind = std::lower_bound(array, array + n, value);
   if ( (pind != array + n) && (*pind == value) )
      return (pind - array);
   else
      return ( pind - array - 1);
}

template <typename T> Long64_t TMath::BinarySearch(Long64_t n, const T **array, T value)
{
   // Binary search in an array of n values to locate value.
   //
   // Array is supposed  to be sorted prior to this call.
   // If match is found, function returns position of element.
   // If no match found, function gives nearest element smaller than value.

   const T* pind;
   pind = std::lower_bound(*array, *array + n, value);
   if ( (pind != *array + n) && (*pind == value) )
      return (pind - *array);
   else
      return ( pind - *array - 1);
}

template <typename Iterator, typename IndexIterator>
void TMath::SortItr(Iterator first, Iterator last, IndexIterator index, Bool_t down)
{
   // Sort the n1 elements of the Short_t array defined by its
   // iterators.  In output the array index contains the indices of
   // the sorted array.  If down is false sort in increasing order
   // (default is decreasing order).

   // NOTE that the array index must be created with a length bigger
   // or equal than the main array before calling this function.

   int i = 0;

   IndexIterator cindex = index;
   for ( Iterator cfirst = first; cfirst != last; ++cfirst )
   {
      *cindex = i++;
      ++cindex;
   }

   if ( down )
      std::sort(index, cindex, CompareDesc<Iterator>(first) );
   else
      std::sort(index, cindex, CompareAsc<Iterator>(first) );
}

template <typename Element, typename Index> void TMath::Sort(Index n, const Element* a, Index* index, Bool_t down)
{
   // Sort the n elements of the  array a of generic templated type Element.
   // In output the array index of type Index contains the indices of the sorted array.
   // If down is false sort in increasing order (default is decreasing order).

   // NOTE that the array index must be created with a length >= n
   // before calling this function.
   // NOTE also that the size type for n must be the same type used for the index array
   // (templated type Index)

   for(Index i = 0; i < n; i++) { index[i] = i; }
   if ( down )
      std::sort(index, index + n, CompareDesc<const Element*>(a) );
   else
      std::sort(index, index + n, CompareAsc<const Element*>(a) );
}

template <typename T> T *TMath::Cross(const T v1[3],const T v2[3], T out[3])
{
   // Calculate the Cross Product of two vectors:
   //         out = [v1 x v2]

   out[0] = v1[1] * v2[2] - v1[2] * v2[1];
   out[1] = v1[2] * v2[0] - v1[0] * v2[2];
   out[2] = v1[0] * v2[1] - v1[1] * v2[0];

   return out;
}

template <typename T> T * TMath::Normal2Plane(const T p1[3],const T p2[3],const T p3[3], T normal[3])
{
   // Calculate a normal vector of a plane.
   //
   //  Input:
   //     Float_t *p1,*p2,*p3  -  3 3D points belonged the plane to define it.
   //
   //  Return:
   //     Pointer to 3D normal vector (normalized)

   T v1[3], v2[3];

   v1[0] = p2[0] - p1[0];
   v1[1] = p2[1] - p1[1];
   v1[2] = p2[2] - p1[2];

   v2[0] = p3[0] - p1[0];
   v2[1] = p3[1] - p1[1];
   v2[2] = p3[2] - p1[2];

   NormCross(v1,v2,normal);
   return normal;
}

template <typename T> Bool_t TMath::IsInside(T xp, T yp, Int_t np, T *x, T *y)
{
   // Function which returns kTRUE if point xp,yp lies inside the
   // polygon defined by the np points in arrays x and y, kFALSE otherwise.
   // Note that the polygon may be open or closed.

   Int_t i, j = np-1 ;
   Bool_t oddNodes = kFALSE;

   for (i=0; i<np; i++) {
      if ((y[i]<yp && y[j]>=yp) || (y[j]<yp && y[i]>=yp)) {
         if (x[i]+(yp-y[i])/(y[j]-y[i])*(x[j]-x[i])<xp) {
            oddNodes = !oddNodes;
         }
      }
      j=i;
   }

   return oddNodes;
}

template <typename T> Double_t TMath::Median(Long64_t n, const T *a, const Double_t *w, Long64_t *work)
{
   // Return the median of the array a where each entry i has weight w[i] .
   // Both arrays have a length of at least n . The median is a number obtained
   // from the sorted array a through
   //
   // median = (a[jl]+a[jh])/2.  where (using also the sorted index on the array w)
   //
   // sum_i=0,jl w[i] <= sumTot/2
   // sum_i=0,jh w[i] >= sumTot/2
   // sumTot = sum_i=0,n w[i]
   //
   // If w=0, the algorithm defaults to the median definition where it is
   // a number that divides the sorted sequence into 2 halves.
   // When n is odd or n > 1000, the median is kth element k = (n + 1) / 2.
   // when n is even and n < 1000the median is a mean of the elements k = n/2 and k = n/2 + 1.
   //
   // If the weights are supplied (w not 0) all weights must be >= 0
   //
   // If work is supplied, it is used to store the sorting index and assumed to be
   // >= n . If work=0, local storage is used, either on the stack if n < kWorkMax
   // or on the heap for n >= kWorkMax .

   const Int_t kWorkMax = 100;

   if (n <= 0 || !a) return 0;
   Bool_t isAllocated = kFALSE;
   Double_t median;
   Long64_t *ind;
   Long64_t workLocal[kWorkMax];

   if (work) {
      ind = work;
   } else {
      ind = workLocal;
      if (n > kWorkMax) {
         isAllocated = kTRUE;
         ind = new Long64_t[n];
      }
   }

   if (w) {
      Double_t sumTot2 = 0;
      for (Int_t j = 0; j < n; j++) {
         if (w[j] < 0) {
            ::Error("TMath::Median","w[%d] = %.4e < 0 ?!",j,w[j]);
            if (isAllocated) delete [] ind;
            return 0;
         }
         sumTot2 += w[j];
      }

      sumTot2 /= 2.;

      Sort(n, a, ind, kFALSE);

      Double_t sum = 0.;
      Int_t jl;
      for (jl = 0; jl < n; jl++) {
         sum += w[ind[jl]];
         if (sum >= sumTot2) break;
      }

      Int_t jh;
      sum = 2.*sumTot2;
      for (jh = n-1; jh >= 0; jh--) {
         sum -= w[ind[jh]];
         if (sum <= sumTot2) break;
      }

      median = 0.5*(a[ind[jl]]+a[ind[jh]]);

   } else {

      if (n%2 == 1)
         median = KOrdStat(n, a,n/2, ind);
      else {
         median = 0.5*(KOrdStat(n, a, n/2 -1, ind)+KOrdStat(n, a, n/2, ind));
      }
   }

   if (isAllocated)
      delete [] ind;
   return median;
}




template <class Element, typename Size>
Element TMath::KOrdStat(Size n, const Element *a, Size k, Size *work)
{
   // Returns k_th order statistic of the array a of size n
   // (k_th smallest element out of n elements).
   //
   // C-convention is used for array indexing, so if you want
   // the second smallest element, call KOrdStat(n, a, 1).
   //
   // If work is supplied, it is used to store the sorting index and
   // assumed to be >= n. If work=0, local storage is used, either on
   // the stack if n < kWorkMax or on the heap for n >= kWorkMax.
   // Note that the work index array will not contain the sorted indices but 
   // all indeces of the smaller element in arbitrary order in work[0,...,k-1] and 
   // all indeces of the larger element in arbitrary order in work[k+1,..,n-1]
   // work[k] will contain instead the index of the returned element.
   //
   // Taken from "Numerical Recipes in C++" without the index array
   // implemented by Anna Khreshuk.
   //
   // See also the declarations at the top of this file

   const Int_t kWorkMax = 100;

   typedef Size Index;

   Bool_t isAllocated = kFALSE;
   Size i, ir, j, l, mid;
   Index arr;
   Index *ind;
   Index workLocal[kWorkMax];
   Index temp;

   if (work) {
      ind = work;
   } else {
      ind = workLocal;
      if (n > kWorkMax) {
         isAllocated = kTRUE;
         ind = new Index[n];
      }
   }

   for (Size ii=0; ii<n; ii++) {
      ind[ii]=ii;
   }
   Size rk = k;
   l=0;
   ir = n-1;
   for(;;) {
      if (ir<=l+1) { //active partition contains 1 or 2 elements
         if (ir == l+1 && a[ind[ir]]<a[ind[l]])
            {temp = ind[l]; ind[l]=ind[ir]; ind[ir]=temp;}
         Element tmp = a[ind[rk]];
         if (isAllocated)
            delete [] ind;
         return tmp;
      } else {
         mid = (l+ir) >> 1; //choose median of left, center and right
         {temp = ind[mid]; ind[mid]=ind[l+1]; ind[l+1]=temp;}//elements as partitioning element arr.
         if (a[ind[l]]>a[ind[ir]]) //also rearrange so that a[l]<=a[l+1]
            {temp = ind[l]; ind[l]=ind[ir]; ind[ir]=temp;}

         if (a[ind[l+1]]>a[ind[ir]])
            {temp=ind[l+1]; ind[l+1]=ind[ir]; ind[ir]=temp;}

         if (a[ind[l]]>a[ind[l+1]])
            {temp = ind[l]; ind[l]=ind[l+1]; ind[l+1]=temp;}

         i=l+1; //initialize pointers for partitioning
         j=ir;
         arr = ind[l+1];
         for (;;){
            do i++; while (a[ind[i]]<a[arr]);
            do j--; while (a[ind[j]]>a[arr]);
            if (j<i) break; //pointers crossed, partitioning complete
               {temp=ind[i]; ind[i]=ind[j]; ind[j]=temp;}
         }
         ind[l+1]=ind[j];
         ind[j]=arr;
         if (j>=rk) ir = j-1; //keep active the partition that
         if (j<=rk) l=i; //contains the k_th element
      }
   }
}
# 27 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TText.h" 1
// @(#)root/graf:$Id: TText.h 33120 2010-04-21 14:29:04Z couet $
// Author: Nicolas Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TText                                                                //
//                                                                      //
// Text.                                                                //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 34 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TText.h"
class TText : public TNamed, public TAttText {

protected:
   Double_t fX; // X position of text (left,center,etc..)
   Double_t fY; // Y position of text (left,center,etc..)

public:
   // TText status bits
   enum { kTextNDC = (1ULL << (14)) };

   TText();
   TText(Double_t x, Double_t y, const char *text);
   TText(const TText &text);
   virtual ~TText();
   void Copy(TObject &text) const;
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual TText *DrawText(Double_t x, Double_t y, const char *text);
   virtual TText *DrawTextNDC(Double_t x, Double_t y, const char *text);
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);

   virtual void GetControlBox(Int_t x, Int_t y, Double_t theta,
                                  Int_t cBoxX[4], Int_t cBoxY[4]);
   Double_t GetX() const { return fX; }
   virtual void GetBoundingBox(UInt_t &w, UInt_t &h, Bool_t angle = kFALSE);
   virtual void GetTextAscentDescent(UInt_t &a, UInt_t &d, const char *text) const;
   virtual void GetTextExtent(UInt_t &w, UInt_t &h, const char *text) const;
   virtual void GetTextAdvance(UInt_t &a, const char *text, const Bool_t kern=kTRUE) const;
   Double_t GetY() const { return fY; }

   virtual void ls(Option_t *option="") const;
   virtual void Paint(Option_t *option="");
   virtual void PaintControlBox(Int_t x, Int_t y, Double_t theta);
   virtual void PaintText(Double_t x, Double_t y, const char *text);
   virtual void PaintTextNDC(Double_t u, Double_t v, const char *text);
   virtual void Print(Option_t *option="") const;
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetNDC(Bool_t isNDC=kTRUE);
   virtual void SetText(Double_t x, Double_t y, const char *text) {fX=x; fY=y; SetTitle(text);} // *MENU* *ARGS={x=>fX,y=>fY,text=>fTitle}
   virtual void SetX(Double_t x) { fX = x; } // *MENU*
   virtual void SetY(Double_t y) { fY = y; } // *MENU*

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TText::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TText::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TText.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 75; } //Text
};
# 28 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h" 1
// @(#)root/tree:$Id: TTree.h 44280 2012-05-18 06:05:10Z pcanal $
// Author: Rene Brun   12/01/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 29 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLatex.h" 1
// @(#)root/graf:$Id: TLatex.h 33468 2010-05-11 14:09:36Z couet $
// Author: Nicolas Brun   07/08/98

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 24 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLatex.h"
//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TLatex                                                               //
//                                                                      //
// The Latex-style text processor class                                 //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


struct FormSize_t {
      Double_t fWidth, fOver, fUnder;
};

struct TextSpec_t {
   Double_t fAngle,fSize;
   Int_t fColor,fFont;
};

// compute size of a portion of a formula
class TLatexFormSize {
private:
      Double_t fWidth, fOver, fUnder;
public:
      TLatexFormSize() : fWidth(0), fOver(0),fUnder(0) { } // constructeur par defaut
      TLatexFormSize(Double_t x, Double_t y1, Double_t y2) : fWidth(x), fOver(y1), fUnder(y2) { } // constructeur
      virtual ~TLatexFormSize() {} //destructeur
      TLatexFormSize(const TLatexFormSize& form)
         : fWidth(form.fWidth), fOver(form.fOver), fUnder(form.fUnder) { }

      // definition of operators + and +=
      TLatexFormSize operator+(TLatexFormSize f)
         { return TLatexFormSize(f.Width()+fWidth,TMath::Max(f.Over(),fOver),TMath::Max(f.Under(),fUnder)); }
      void operator+=(TLatexFormSize f)
         { fWidth += f.Width(); fOver = TMath::Max(fOver,f.Over()); fUnder = TMath::Max(fUnder,f.Under()); }

      inline void Set(Double_t x, Double_t y1, Double_t y2) { fWidth=x; fOver=y1; fUnder=y2; }
      TLatexFormSize AddOver(TLatexFormSize f)
         { return TLatexFormSize(f.Width()+fWidth,f.Height()+fOver,fUnder); }
      TLatexFormSize AddUnder(TLatexFormSize f)
         { return TLatexFormSize(f.Width()+fWidth,fOver,f.Height()+fUnder); }
      TLatexFormSize AddOver(TLatexFormSize f1, TLatexFormSize f2)
         { return TLatexFormSize(fWidth+TMath::Max(f1.Width(),f2.Width()),fOver+f1.Over(),fUnder+f2.Under()); }

      // return members
      inline Double_t Width() const { return fWidth; }
      inline Double_t Over() const { return fOver; }
      inline Double_t Under() const { return fUnder; }
      inline Double_t Height() const { return fOver+fUnder; }
};

class TLatex : public TText, public TAttLine {

protected:
      Double_t fFactorSize; //!Relative size of subscripts and superscripts
      Double_t fFactorPos; //!Relative position of subscripts and superscripts
      Int_t fLimitFactorSize; // lower bound for subscripts/superscripts size
      const Char_t *fError; //!error code
      Bool_t fShow; //!is true during the second pass (Painting)
      FormSize_t *fTabSize; //!array of values for the different zones
      Double_t fOriginSize; // Font size of the starting font
      Int_t fTabMax; //!Maximum allocation for array fTabSize;
      Int_t fPos; //!Current position in array fTabSize;
      Bool_t fItalic; //!Currently inside #it operator

      TLatex& operator=(const TLatex&);

      //Text analysis and painting
      TLatexFormSize Analyse(Double_t x, Double_t y, TextSpec_t spec, const Char_t* t,Int_t length);
      TLatexFormSize Anal1(TextSpec_t spec, const Char_t* t,Int_t length);

      void DrawLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2, TextSpec_t spec);
      void DrawCircle(Double_t x1, Double_t y1, Double_t r, TextSpec_t spec);
      void DrawParenthesis(Double_t x1, Double_t y1, Double_t r1, Double_t r2, Double_t phimin, Double_t phimax, TextSpec_t spec);

      TLatexFormSize FirstParse(Double_t angle, Double_t size, const Char_t *text);

      void Savefs(TLatexFormSize *fs);
      TLatexFormSize Readfs();

      Int_t CheckLatexSyntax(TString &text) ;

public:
      // TLatex status bits
      enum { kTextNDC = (1ULL << (14)) };

      TLatex();
      TLatex(Double_t x, Double_t y, const char *text);
      TLatex(const TLatex &text);
      virtual ~TLatex();
      void Copy(TObject &text) const;

      TLatex *DrawLatex(Double_t x, Double_t y, const char *text);
      Double_t GetHeight() const;
      Double_t GetXsize();
      Double_t GetYsize();
      void GetBoundingBox(UInt_t &w, UInt_t &h, Bool_t angle = kFALSE);
      virtual void Paint(Option_t *option="");
      virtual void PaintLatex(Double_t x, Double_t y, Double_t angle, Double_t size, const char *text);

      virtual void SavePrimitive(ostream &out, Option_t *option = "");
      virtual void SetIndiceSize(Double_t factorSize);
      virtual void SetLimitIndiceSize(Int_t limitFactorSize);

      private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TLatex::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TLatex::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLatex.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 127; } //The Latex-style text processor class
};
# 30 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLegend.h" 1
// @(#)root/graf:$Id: TLegend.h 26711 2008-12-06 19:50:17Z brun $
// Author: Matthew.Adam.Dobbs   06/09/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
//--------------------------------------------------------------------------




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TLegend        (a second attempt- the first was TPadLegend           //
// Matthew.Adam.Dobbs@Cern.CH, September 1999                           //
// Legend of markers/lines/boxes for histos & graphs                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 31 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLegend.h"
class TObject;
class TList;
class TLegendEntry;

class TLegend : public TPave , public TAttText {

protected:
   TLegend& operator=(const TLegend&);

public:
   TLegend();
   TLegend( Double_t x1, Double_t y1, Double_t x2, Double_t y2,
            const char* header = "", Option_t* option="brNDC" );
   virtual ~TLegend();
   TLegend( const TLegend &legend );

   TLegendEntry *AddEntry(const TObject* obj, const char* label = "", Option_t* option = "lpf" );
   TLegendEntry *AddEntry(const char *name, const char* label = "", Option_t* option = "lpf" );
   virtual void Clear( Option_t* option = "" ); // *MENU*
   virtual void Copy( TObject &obj ) const;
   virtual void DeleteEntry(); // *MENU*
   virtual void Draw( Option_t* option = "" );
   virtual void EditEntryAttFill();
   virtual void EditEntryAttLine();
   virtual void EditEntryAttMarker();
   virtual void EditEntryAttText();
   Float_t GetColumnSeparation() const { return fColumnSeparation; }
   TLegendEntry *GetEntry() const;
   Float_t GetEntrySeparation() const { return fEntrySeparation; }
   virtual const char *GetHeader() const;
   TList *GetListOfPrimitives() const {return fPrimitives;}
   Float_t GetMargin() const { return fMargin; }
   Int_t GetNColumns() const { return fNColumns; }
   Int_t GetNRows() const;
   virtual void InsertEntry( const char* objectName = "",const char* label = "",
                             Option_t* option = "lpf" ); // *MENU*
   virtual void Paint( Option_t* option = "" );
   virtual void PaintPrimitives();
   virtual void Print( Option_t* option = "" ) const;
   virtual void RecursiveRemove(TObject *obj);
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   void SetDefaults() { fEntrySeparation = 0.1f; fMargin = 0.25f; fNColumns = 1; fColumnSeparation = 0.0f; }
   void SetColumnSeparation( Float_t columnSeparation )
                     { fColumnSeparation = columnSeparation; } // *MENU*
   virtual void SetEntryLabel( const char* label ); // *MENU*
   virtual void SetEntryOption( Option_t* option ); // *MENU*
   void SetEntrySeparation( Float_t entryseparation )
                     { fEntrySeparation = entryseparation; } // *MENU*
   virtual void SetHeader( const char *header = "" ); // *MENU*
   void SetMargin( Float_t margin ) { fMargin = margin; } // *MENU*
   void SetNColumns( Int_t nColumns ); // *MENU*

protected:
   TList *fPrimitives; // list of TLegendEntries
   Float_t fEntrySeparation; // separation between entries, as a fraction of
                                 // the space allocated to one entry.
                                 // Typical value is 0.1.
   Float_t fMargin; // fraction of total width used for symbol
   Int_t fNColumns; // number of columns in the legend
   Float_t fColumnSeparation; // separation between columns, as a fraction of 
                                 // the space allowed to one column

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TLegend::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TLegend::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLegend.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 93; } // Legend of markers/lines/boxes to represent obj's
};
# 31 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TChain.h" 1
// @(#)root/tree:$Id: TChain.h 42754 2012-01-20 20:13:07Z pcanal $
// Author: Rene Brun   03/02/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TChain                                                               //
//                                                                      //
// A chain of TTrees.                                                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TFile;
class TBrowser;
class TCut;
class TEntryList;
class TEventList;
class TCollection;

class TChain : public TTree {

protected:
   Int_t fTreeOffsetLen; //  Current size of fTreeOffset array
   Int_t fNtrees; //  Number of trees
   Int_t fTreeNumber; //! Current Tree number in fTreeOffset table
   Long64_t *fTreeOffset; //[fTreeOffsetLen] Array of variables
   Bool_t fCanDeleteRefs; //! If true, TProcessIDs are deleted when closing a file
   TTree *fTree; //! Pointer to current tree (Note: We do *not* own this tree.)
   TFile *fFile; //! Pointer to current file (We own the file).
   TObjArray *fFiles; //-> List of file names containing the trees (TChainElement, owned)
   TList *fStatus; //-> List of active/inactive branches (TChainElement, owned)
   TChain *fProofChain; //! chain proxy when going to be processed by PROOF

private:
   TChain(const TChain&); // not implemented
   TChain& operator=(const TChain&); // not implemented

protected:
   void InvalidateCurrentTree();
   void ReleaseChainProof();

public:
   // TChain constants
   enum {
      kGlobalWeight = (1ULL << (15)),
      kAutoDelete = (1ULL << (16)),
      kProofUptodate = (1ULL << (17)),
      kProofLite = (1ULL << (18)),
      kBigNumber = 1234567890
   };

public:
   TChain();
   TChain(const char* name, const char* title = "");
   virtual ~TChain();

   virtual Int_t Add(TChain* chain);
   virtual Int_t Add(const char* name, Long64_t nentries = kBigNumber);
   virtual Int_t AddFile(const char* name, Long64_t nentries = kBigNumber, const char* tname = "");
   virtual Int_t AddFileInfoList(TCollection* list, Long64_t nfiles = kBigNumber);
   virtual TFriendElement *AddFriend(const char* chainname, const char* dummy = "");
   virtual TFriendElement *AddFriend(const char* chainname, TFile* dummy);
   virtual TFriendElement *AddFriend(TTree* chain, const char* alias = "", Bool_t warn = kFALSE);
   virtual void Browse(TBrowser*);
   virtual void CanDeleteRefs(Bool_t flag = kTRUE);
   virtual void CreatePackets();
   virtual void DirectoryAutoAdd(TDirectory *);
   virtual Long64_t Draw(const char* varexp, const TCut& selection, Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0);
   virtual Long64_t Draw(const char* varexp, const char* selection, Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0); // *MENU*
   virtual void Draw(Option_t* opt) { Draw(opt, "", "", 1000000000, 0); }
   virtual Int_t Fill() { MayNotUse("Fill()"); return -1; }
   virtual TBranch *FindBranch(const char* name);
   virtual TLeaf *FindLeaf(const char* name);
   virtual TBranch *GetBranch(const char* name);
   virtual Bool_t GetBranchStatus(const char* branchname) const;
   virtual Long64_t GetChainEntryNumber(Long64_t entry) const;
   virtual TClusterIterator GetClusterIterator(Long64_t firstentry);
           Int_t GetNtrees() const { return fNtrees; }
   virtual Long64_t GetEntries() const;
   virtual Long64_t GetEntries(const char *sel) { return TTree::GetEntries(sel); }
   virtual Int_t GetEntry(Long64_t entry=0, Int_t getall=0);
   virtual Long64_t GetEntryNumber(Long64_t entry) const;
   virtual Int_t GetEntryWithIndex(Int_t major, Int_t minor=0);
   TFile *GetFile() const;
   virtual TLeaf *GetLeaf(const char* branchname, const char* leafname);
   virtual TLeaf *GetLeaf(const char* name);
   virtual TObjArray *GetListOfBranches();
   //                Warning, GetListOfFiles returns the list of TChainElements (not the list of files)
   //                see TChain::AddFile to see how to get the corresponding TFile objects
   TObjArray *GetListOfFiles() const {return fFiles;}
   virtual TObjArray *GetListOfLeaves();
   virtual const char *GetAlias(const char *aliasName) const;
   virtual Double_t GetMaximum(const char *columname);
   virtual Double_t GetMinimum(const char *columname);
   virtual Int_t GetNbranches();
   virtual Long64_t GetReadEntry() const;
   TList *GetStatus() const { return fStatus; }
   virtual TTree *GetTree() const { return fTree; }
   virtual Int_t GetTreeNumber() const { return fTreeNumber; }
           Long64_t *GetTreeOffset() const { return fTreeOffset; }
           Int_t GetTreeOffsetLen() const { return fTreeOffsetLen; }
   virtual Double_t GetWeight() const;
   virtual Int_t LoadBaskets(Long64_t maxmemory);
   virtual Long64_t LoadTree(Long64_t entry);
           void Lookup(Bool_t force = kFALSE);
   virtual void Loop(Option_t *option="", Long64_t nentries=kBigNumber, Long64_t firstentry=0); // *MENU*
   virtual void ls(Option_t *option="") const;
   virtual Long64_t Merge(const char *name, Option_t *option = "");
   virtual Long64_t Merge(TCollection *list, Option_t *option = "");
   virtual Long64_t Merge(TCollection *list, TFileMergeInfo *info);
   virtual Long64_t Merge(TFile *file, Int_t basketsize, Option_t *option="");
   virtual void Print(Option_t *option="") const;
   virtual Long64_t Process(const char *filename, Option_t *option="", Long64_t nentries=kBigNumber, Long64_t firstentry=0); // *MENU*







   virtual void RecursiveRemove(TObject *obj);
   virtual void Reset(Option_t *option="");
   virtual void ResetAfterMerge(TFileMergeInfo *);
   virtual void ResetBranchAddress(TBranch *);
   virtual void ResetBranchAddresses();
   virtual Long64_t Scan(const char *varexp="", const char *selection="", Option_t *option="", Long64_t nentries=1000000000, Long64_t firstentry=0); // *MENU*
   virtual void SetAutoDelete(Bool_t autodel=kTRUE);
   virtual Int_t SetBranchAddress(const char *bname,void *add, TBranch **ptr = 0);
   virtual Int_t SetBranchAddress(const char *bname,void *add, TBranch **ptr, TClass *realClass, EDataType datatype, Bool_t isptr);
   virtual Int_t SetBranchAddress(const char *bname,void *add, TClass *realClass, EDataType datatype, Bool_t isptr);

   virtual void SetBranchStatus(const char *bname, Bool_t status=1, UInt_t *found=0);
   virtual void SetCacheSize(Long64_t cacheSize);
   virtual void SetDirectory(TDirectory *dir);
   virtual void SetEntryList(TEntryList *elist, Option_t *opt="");
   virtual void SetEntryListFile(const char *filename="", Option_t *opt="");
   virtual void SetEventList(TEventList *evlist);
   virtual void SetMakeClass(Int_t make) { TTree::SetMakeClass(make); if (fTree) fTree->SetMakeClass(make);}
   virtual void SetPacketSize(Int_t size = 100);
   virtual void SetProof(Bool_t on = kTRUE, Bool_t refresh = kFALSE, Bool_t gettreeheader = kFALSE);
   virtual void SetWeight(Double_t w=1, Option_t *option="");
   virtual void UseCache(Int_t maxCacheSize = 10, Int_t pageSize = 0);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 5; } static void Dictionary(); virtual TClass *IsA() const { return TChain::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TChain::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TChain.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 159; } //A chain of TTrees
};
# 32 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGaxis.h" 1
// @(#)root/graf:$Id: TGaxis.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun, Olivier Couet   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGaxis                                                               //
//                                                                      //
// Service class for the graphical representation of axis.              //
// Instances of this class are generated by the histogram classes and   //
// TGraph.                                                              //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
# 36 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGaxis.h"
class TF1;
class TAxis;

class TGaxis : public TLine, public TAttText {

protected:
   Double_t fWmin; //Lowest value on the axis
   Double_t fWmax; //Highest value on the axis
   Float_t fGridLength; //Length of the grid in NDC
   Float_t fTickSize; //Size of primary tick mark in NDC
   Float_t fLabelOffset; //Offset of label wrt axis
   Float_t fLabelSize; //Size of labels in NDC
   Float_t fTitleOffset; //Offset of title wrt axis
   Float_t fTitleSize; //Size of title in NDC
   Int_t fNdiv; //Number of divisions
   Int_t fLabelColor; //Color for labels
   Int_t fLabelFont; //Font for labels
   TString fChopt; //Axis options
   TString fName; //axis name
   TString fTitle; //axis title
   TString fTimeFormat; //Time format, ex: 09/12/99 12:34:00
   TString fFunctionName; //name of mapping function pointed by fFunction
   TF1 *fFunction; //!Pointer to function computing axis values
   TAxis *fAxis; //!pointer to original TAxis axis (if any)

   static Int_t fgMaxDigits; //!Number of digits above which the 10>N notation is used

   TGaxis(const TGaxis&);
   TGaxis& operator=(const TGaxis&);

public:

   TGaxis();
   TGaxis(Double_t xmin,Double_t ymin,Double_t xmax,Double_t ymax,
          Double_t wmin,Double_t wmax,Int_t ndiv=510, Option_t *chopt="",
          Double_t gridlength = 0);
   TGaxis(Double_t xmin,Double_t ymin,Double_t xmax,Double_t ymax,
          const char *funcname, Int_t ndiv=510, Option_t *chopt="",
          Double_t gridlength = 0);
   virtual ~TGaxis();

   virtual void AdjustBinSize(Double_t A1, Double_t A2, Int_t nold
                                    ,Double_t &BinLow, Double_t &BinHigh, Int_t &nbins, Double_t &BinWidth);
   virtual void CenterLabels(Bool_t center=kTRUE);
   virtual void CenterTitle(Bool_t center=kTRUE);
   virtual void DrawAxis(Double_t xmin,Double_t ymin,Double_t xmax,Double_t ymax,
                                Double_t wmin,Double_t wmax,Int_t ndiv=510, Option_t *chopt="",
                                Double_t gridlength = 0);
   Float_t GetGridLength() const {return fGridLength;}
   TF1 *GetFunction() const {return fFunction;}
   Int_t GetLabelColor() const {return fLabelColor;}
   Int_t GetLabelFont() const {return fLabelFont;}
   Float_t GetLabelOffset() const {return fLabelOffset;}
   Float_t GetLabelSize() const {return fLabelSize;}
   Float_t GetTitleOffset() const {return fTitleOffset;}
   Float_t GetTitleSize() const {return fTitleSize;}
   virtual const char *GetName() const {return fName.Data();}
   virtual const char *GetOption() const {return fChopt.Data();}
   virtual const char *GetTitle() const {return fTitle.Data();}
   static Int_t GetMaxDigits();
   Int_t GetNdiv() const {return fNdiv;}
   Double_t GetWmin() const {return fWmin;}
   Double_t GetWmax() const {return fWmax;}
   Float_t GetTickSize() const {return fTickSize;}
   virtual void ImportAxisAttributes(TAxis *axis);
   void LabelsLimits(const char *label, Int_t &first, Int_t &last);
   virtual void Paint(Option_t *chopt="");
   virtual void PaintAxis(Double_t xmin,Double_t ymin,Double_t xmax,Double_t ymax,
                                 Double_t &wmin,Double_t &wmax,Int_t &ndiv, Option_t *chopt="",
                                 Double_t gridlength = 0, Bool_t drawGridOnly = kFALSE);
   virtual void Rotate(Double_t X, Double_t Y, Double_t CFI, Double_t SFI
                             ,Double_t XT, Double_t YT, Double_t &U, Double_t &V);
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   void SetFunction(const char *funcname="");
   void SetOption(Option_t *option="");
   void SetLabelColor(Int_t labelcolor) {fLabelColor = labelcolor;} // *MENU*
   void SetLabelFont(Int_t labelfont) {fLabelFont = labelfont;} // *MENU*
   void SetLabelOffset(Float_t labeloffset) {fLabelOffset = labeloffset;} // *MENU*
   void SetLabelSize(Float_t labelsize) {fLabelSize = labelsize;} // *MENU*
   static void SetMaxDigits(Int_t maxd=5);
   virtual void SetName(const char *name); // *MENU*
   virtual void SetNdivisions(Int_t ndiv) {fNdiv = ndiv;} // *MENU*
   virtual void SetMoreLogLabels(Bool_t more=kTRUE); // *MENU*
   virtual void SetNoExponent(Bool_t noExponent=kTRUE); // *MENU*
   virtual void SetDecimals(Bool_t dot=kTRUE); // *MENU*
   void SetTickSize(Float_t ticksize) {fTickSize = ticksize;} // *MENU*
   void SetGridLength(Float_t gridlength) {fGridLength = gridlength;}
   void SetTimeFormat(const char *tformat);
   void SetTimeOffset(Double_t toffset, Option_t *option="local");
   virtual void SetTitle(const char *title=""); // *MENU*
   void SetTitleOffset(Float_t titleoffset=1) {fTitleOffset = titleoffset;} // *MENU*
   void SetTitleSize(Float_t titlesize) {fTitleSize = titlesize;} // *MENU*
   void SetTitleFont(Int_t titlefont) {SetTextFont(titlefont);} // *MENU*
   void SetTitleColor(Int_t titlecolor) {SetTextColor(titlecolor);} // *MENU*
   void SetWmin(Double_t wmin) {fWmin = wmin;}
   void SetWmax(Double_t wmax) {fWmax = wmax;}

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 5; } static void Dictionary(); virtual TClass *IsA() const { return TGaxis::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TGaxis::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGaxis.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 133; } //Graphics axis
};
# 33 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMultiGraph.h" 1
// @(#)root/hist:$Id: TMultiGraph.h 43622 2012-04-03 13:24:13Z couet $
// Author: Rene Brun   12/10/2000

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMultiGraph                                                          //
//                                                                      //
// A collection of TGraph objects                                       //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h" 1
// @(#)root/hist:$Id: TF1.h 36906 2010-11-24 15:52:01Z moneta $
// Author: Rene Brun   18/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
// ---------------------------------- F1.h
# 29 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMultiGraph.h" 2

class TH1F;
class TAxis;
class TBrowser;
class TGraph;

# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFitResultPtr.h" 1
// @(#)root/mathcore:$Id: TFitResultPtr.h 31262 2009-11-18 07:38:37Z brun $
// Author: David Gonzalez Maline Tue Nov 10 15:01:24 2009

/*************************************************************************
 * Copyright (C) 1995-2009, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 36 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMultiGraph.h" 2

class TMultiGraph : public TNamed {

protected:
   TList *fGraphs; //Pointer to list of TGraphs
   TList *fFunctions; //Pointer to list of functions (fits and user)
   TH1F *fHistogram; //Pointer to histogram used for drawing axis
   Double_t fMaximum; //Maximum value for plotting along y
   Double_t fMinimum; //Minimum value for plotting along y

   TMultiGraph(const TMultiGraph&);
   TMultiGraph& operator=(const TMultiGraph&);

public:
   TMultiGraph();
   TMultiGraph(const char *name, const char *title);
   virtual ~TMultiGraph();

   virtual void Add(TGraph *graph, Option_t *chopt="");
   virtual void Add(TMultiGraph *multigraph, Option_t *chopt="");
   virtual void Browse(TBrowser *b);
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual void Draw(Option_t *chopt="");
   virtual TFitResultPtr Fit(const char *formula ,Option_t *option="" ,Option_t *goption="", Axis_t xmin=0, Axis_t xmax=0);
   virtual TFitResultPtr Fit(TF1 *f1 ,Option_t *option="" ,Option_t *goption="", Axis_t rxmin=0, Axis_t rxmax=0);
   virtual void FitPanel(); // *MENU*
   virtual Option_t *GetGraphDrawOption(const TGraph *gr) const;
   virtual void LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double_t &a1, Int_t &ifail, Double_t xmin, Double_t xmax);
   virtual void LeastSquareFit(Int_t m, Double_t *a, Double_t xmin, Double_t xmax);
   virtual void InitPolynom(Double_t xmin, Double_t xmax);
   virtual void InitExpo(Double_t xmin, Double_t xmax);
   virtual void InitGaus(Double_t xmin, Double_t xmax);
   virtual Int_t IsInside(Double_t x, Double_t y) const;
   TH1F *GetHistogram() const;
   TF1 *GetFunction(const char *name) const;
   TList *GetListOfGraphs() const { return fGraphs; }
   TList *GetListOfFunctions(); // non const method (create list if empty)
   const TList *GetListOfFunctions() const { return fFunctions; }
   TAxis *GetXaxis() const;
   TAxis *GetYaxis() const;
   virtual void Paint(Option_t *chopt="");
   void PaintPolyLine3D(Option_t *chopt="");
   virtual void Print(Option_t *chopt="") const;
   virtual void RecursiveRemove(TObject *obj);
   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SetMaximum(Double_t maximum=-1111);
   virtual void SetMinimum(Double_t minimum=-1111);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 2; } static void Dictionary(); virtual TClass *IsA() const { return TMultiGraph::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TMultiGraph::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMultiGraph.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 84; } //A collection of TGraph objects
};
# 34 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSpectrum.h" 1
// @(#)root/spectrum:$Id: TSpectrum.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Miroslav Morhac   27/05/99

/*************************************************************************
 * Copyright (C) 1995-2006, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/







class TH1;

class TSpectrum : public TNamed {
private:

   TSpectrum(const TSpectrum&); // Not implemented
   TSpectrum& operator=(const TSpectrum&); // Not implemented

protected:
   Int_t fMaxPeaks; //Maximum number of peaks to be found
   Int_t fNPeaks; //number of peaks found
   Float_t *fPosition; //[fNPeaks] array of current peak positions
   Float_t *fPositionX; //[fNPeaks] X position of peaks
   Float_t *fPositionY; //[fNPeaks] Y position of peaks
   Float_t fResolution; //resolution of the neighboring peaks
   TH1 *fHistogram; //resulting histogram
static Int_t fgAverageWindow; //Average window of searched peaks
static Int_t fgIterations; //Maximum number of decon iterations (default=3)

public:
   enum {
       kBackOrder2 =0,
       kBackOrder4 =1,
       kBackOrder6 =2,
       kBackOrder8 =3,
       kBackIncreasingWindow =0,
       kBackDecreasingWindow =1,
       kBackSmoothing3 =3,
       kBackSmoothing5 =5,
       kBackSmoothing7 =7,
       kBackSmoothing9 =9,
       kBackSmoothing11 =11,
       kBackSmoothing13 =13,
       kBackSmoothing15 =15
   };

   TSpectrum();
   TSpectrum(Int_t maxpositions, Float_t resolution=1);
   virtual ~TSpectrum();
   virtual TH1 *Background(const TH1 *hist,Int_t niter=20, Option_t *option="");
   TH1 *GetHistogram() const {return fHistogram;}
   Int_t GetNPeaks() const {return fNPeaks;}
   Float_t *GetPositionX() const {return fPositionX;}
   Float_t *GetPositionY() const {return fPositionY;}
   virtual void Print(Option_t *option="") const;
   virtual Int_t Search(const TH1 *hist, Double_t sigma=2, Option_t *option="", Double_t threshold=0.05);
   static void SetAverageWindow(Int_t w=3); //set average window
   static void SetDeconIterations(Int_t n=3); //set max number of decon iterations
   void SetResolution(Float_t resolution=1);

   //new functions January 2006
   const char *Background(float *spectrum, Int_t ssize,Int_t numberIterations,Int_t direction, Int_t filterOrder,bool smoothing,Int_t smoothWindow,bool compton);
   const char *SmoothMarkov(float *source, Int_t ssize, Int_t averWindow);
   const char *Deconvolution(float *source, const float *response,Int_t ssize, Int_t numberIterations,Int_t numberRepetitions, Double_t boost );
   const char *DeconvolutionRL(float *source, const float *response,Int_t ssize, Int_t numberIterations,Int_t numberRepetitions, Double_t boost );
   const char *Unfolding(float *source,const float **respMatrix,Int_t ssizex, Int_t ssizey,Int_t numberIterations,Int_t numberRepetitions, Double_t boost);
   Int_t SearchHighRes(float *source,float *destVector, Int_t ssize,float sigma, Double_t threshold,bool backgroundRemove,Int_t deconIterations,bool markov, Int_t averWindow);
   Int_t Search1HighRes(float *source,float *destVector, Int_t ssize,float sigma, Double_t threshold,bool backgroundRemove,Int_t deconIterations,bool markov, Int_t averWindow);

   static Int_t StaticSearch(const TH1 *hist, Double_t sigma=2, Option_t *option="goff", Double_t threshold=0.05);
   static TH1 *StaticBackground(const TH1 *hist,Int_t niter=20, Option_t *option="");

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 3; } static void Dictionary(); virtual TClass *IsA() const { return TSpectrum::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TSpectrum::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSpectrum.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 80; } //Peak Finder, background estimator, Deconvolution
};
# 35 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualFitter.h" 1
// @(#)root/mathcore:$Id: TVirtualFitter.h 25927 2008-10-22 23:42:01Z rdm $
// Author: Rene Brun   31/08/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/




//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TVirtualFitter                                                       //
//                                                                      //
// Abstract base class for fitting                                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////






# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMethodCall.h" 1
// @(#)root/meta:$Id: TMethodCall.h 24077 2008-05-31 19:39:09Z brun $
// Author: Fons Rademakers   13/06/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMethodCall                                                          //
//                                                                      //
// Method or function calling interface. Objects of this class contain  //
// the (CINT) environment to call a global function or a method for an  //
// object of a specific class with the desired arguments. This class is //
// espicially useful when a method has to be called more times for      //
// different objects and/or with different arguments. If a function or  //
// method needs to be called only once one better uses                  //
// TInterpreter::Execute().                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TClass;
class TFunction;

class TMethodCall : public TObject {

public:
   enum EReturnType { kLong, kDouble, kString, kOther, kNone };

private:
   CallFunc_t *fFunc; //CINT method invocation environment
   Long_t fOffset; //offset added to object pointer before method invocation
   TClass *fClass; //pointer to the class info
   TFunction *fMetPtr; //pointer to the method or function info
   TString fMethod; //method name
   TString fParams; //argument string
   TString fProto; //prototype string
   Bool_t fDtorOnly; //call only dtor and not delete when calling ~xxx
   EReturnType fRetType; //method return type

   void Execute(const char *, const char *, int * /*error*/ = 0) { } // versions of TObject
   void Execute(TMethod *, TObjArray *, int * /*error*/ = 0) { }

   void InitImplementation(const char *methodname, const char *params, const char *proto, TClass *cl, const ClassInfo_t *cinfo);

public:
   TMethodCall();
   TMethodCall(TClass *cl, const char *method, const char *params);
   TMethodCall(const char *function, const char *params);
   TMethodCall(const TMethodCall &org);
   TMethodCall& operator=(const TMethodCall &rhs);
   ~TMethodCall();

   void Init(TClass *cl, const char *method, const char *params);
   void Init(const char *function, const char *params);
   void InitWithPrototype(TClass *cl, const char *method, const char *proto);
   void InitWithPrototype(const char *function, const char *proto);
   Bool_t IsValid() const;
   TObject *Clone(const char *newname="") const;
   void CallDtorOnly(Bool_t set = kTRUE) { fDtorOnly = set; }

   TFunction *GetMethod();
   const char *GetMethodName() const { return fMethod.Data(); }
   const char *GetParams() const { return fParams.Data(); }
   const char *GetProto() const { return fProto.Data(); }
   EReturnType ReturnType();

   void SetParamPtrs(void *paramArr, Int_t nparam = -1);
   void ResetParam();
   void SetParam(Long_t l);
   void SetParam(Double_t d);
   void SetParam(Long64_t ll);
   void SetParam(ULong64_t ull);

   void Execute(void *object);
   void Execute(void *object, const char *params);
   void Execute(void *object, Long_t &retLong);
   void Execute(void *object, const char *params, Long_t &retLong);
   void Execute(void *object, Double_t &retDouble);
   void Execute(void *object, const char *params, Double_t &retDouble);

   void Execute(void *object, char **retText);
   void Execute(void *object, const char *params, char **retText);

   void Execute();
   void Execute(const char *params);
   void Execute(Long_t &retLong);
   void Execute(const char *params, Long_t &retLong);
   void Execute(Double_t &retDouble);
   void Execute(const char *params, Double_t &retDouble);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TMethodCall::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TMethodCall::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMethodCall.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 104; } //Method calling interface
};

inline void TMethodCall::Execute()
   { Execute((void *)0); }
inline void TMethodCall::Execute(const char *params)
   { Execute((void *)0, params); }
inline void TMethodCall::Execute(Long_t &retLong)
   { Execute((void *)0, retLong); }
inline void TMethodCall::Execute(const char *params, Long_t &retLong)
   { Execute((void *)0, params, retLong); }
inline void TMethodCall::Execute(Double_t &retDouble)
   { Execute((void *)0, retDouble); }
inline void TMethodCall::Execute(const char *params, Double_t &retDouble)
   { Execute((void *)0, params, retDouble); }
# 29 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualFitter.h" 2

# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Foption.h" 1
/* @(#)root/hist:$Id: Foption.h 31207 2009-11-16 16:52:00Z moneta $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 31 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualFitter.h" 2


class TVirtualFitter : public TNamed {

protected:
   Foption_t fOption; //struct with the fit options
   Int_t fXfirst; //first bin on X axis
   Int_t fXlast; //last  bin on X axis
   Int_t fYfirst; //first bin on Y axis
   Int_t fYlast; //last  bin on Y axis
   Int_t fZfirst; //first bin on Z axis
   Int_t fZlast; //last  bin on Z axis
   Int_t fNpoints; //Number of points to fit
   Int_t fPointSize; //Number of words per point in the cache
   Int_t fCacheSize; //Size of the fCache array
   Double_t *fCache; //[fCacheSize] array of points data (fNpoints*fPointSize < fCacheSize words)
   TObject *fObjectFit; //pointer to object being fitted
   TObject *fUserFunc; //pointer to user theoretical function (a TF1*)
   TMethodCall *fMethodCall; //Pointer to MethodCall in case of interpreted function
   void (*fFCN)(Int_t &npar, Double_t *gin, Double_t &f, Double_t *u, Int_t flag);

   static TVirtualFitter *fgFitter; //Current fitter (default TFitter)
   static Int_t fgMaxpar; //Maximum number of fit parameters for current fitter
   static Int_t fgMaxiter; //Maximum number of iterations
   static Double_t fgErrorDef; //Error definition (default=1)
   static Double_t fgPrecision; //maximum precision
   static TString fgDefault; //name of the default fitter ("Minuit","Fumili",etc)

   TVirtualFitter(const TVirtualFitter& tvf);
   TVirtualFitter& operator=(const TVirtualFitter& tvf);

public:
   TVirtualFitter();
   virtual ~TVirtualFitter();
   virtual Double_t Chisquare(Int_t npar, Double_t *params) const = 0;

   virtual void Clear(Option_t *option="") = 0;
   virtual Int_t ExecuteCommand(const char *command, Double_t *args, Int_t nargs) = 0;
   virtual void FixParameter(Int_t ipar) = 0;
   virtual void GetConfidenceIntervals(Int_t n, Int_t ndim, const Double_t *x, Double_t *ci, Double_t cl=0.95);
   virtual void GetConfidenceIntervals(TObject *obj, Double_t cl=0.95);
   virtual Double_t *GetCovarianceMatrix() const = 0;
   virtual Double_t GetCovarianceMatrixElement(Int_t i, Int_t j) const = 0;
   virtual Int_t GetErrors(Int_t ipar,Double_t &eplus, Double_t &eminus, Double_t &eparab, Double_t &globcc) const = 0;
   typedef void (* FCNFunc_t )(Int_t &npar, Double_t *gin, Double_t &f, Double_t *u, Int_t flag);
   virtual FCNFunc_t GetFCN() { return fFCN; }
   virtual Foption_t GetFitOption() const {return fOption;}
   TMethodCall *GetMethodCall() const {return fMethodCall;}
   virtual Int_t GetNumberTotalParameters() const = 0;
   virtual Int_t GetNumberFreeParameters() const = 0;
   virtual TObject *GetObjectFit() const {return fObjectFit;}
   virtual Double_t GetParError(Int_t ipar) const = 0;
   virtual Double_t GetParameter(Int_t ipar) const = 0;
   virtual Int_t GetParameter(Int_t ipar,char *name,Double_t &value,Double_t &verr,Double_t &vlow, Double_t &vhigh) const = 0;
   virtual const char *GetParName(Int_t ipar) const = 0;
   virtual Int_t GetStats(Double_t &amin, Double_t &edm, Double_t &errdef, Int_t &nvpar, Int_t &nparx) const = 0;
   virtual Double_t GetSumLog(Int_t i) = 0;
   virtual TObject *GetUserFunc() const {return fUserFunc;}
   virtual Int_t GetXfirst() const {return fXfirst;}
   virtual Int_t GetXlast() const {return fXlast;}
   virtual Int_t GetYfirst() const {return fYfirst;}
   virtual Int_t GetYlast() const {return fYlast;}
   virtual Int_t GetZfirst() const {return fZfirst;}
   virtual Int_t GetZlast() const {return fZlast;}
   virtual Bool_t IsFixed(Int_t ipar) const = 0;
   virtual void PrintResults(Int_t level, Double_t amin) const = 0;
   virtual void ReleaseParameter(Int_t ipar) = 0;
   virtual Double_t *SetCache(Int_t npoints, Int_t psize);
   virtual void SetFCN(void *fcn);
   virtual void SetFCN(void (*fcn)(Int_t &, Double_t *, Double_t &f, Double_t *, Int_t));
   virtual void SetFitMethod(const char *name) = 0;
   virtual void SetFitOption(Foption_t option) {fOption = option;}
   virtual void SetObjectFit(TObject *obj) {fObjectFit = obj;}
   virtual Int_t SetParameter(Int_t ipar,const char *parname,Double_t value,Double_t verr,Double_t vlow, Double_t vhigh) = 0;
   virtual void SetUserFunc(TObject *userfunc) {fUserFunc = userfunc;}
   virtual void SetXfirst(Int_t first) {fXfirst = first;}
   virtual void SetXlast (Int_t last) {fXlast = last;}
   virtual void SetYfirst(Int_t first) {fYfirst = first;}
   virtual void SetYlast (Int_t last) {fYlast = last;}
   virtual void SetZfirst(Int_t first) {fZfirst = first;}
   virtual void SetZlast (Int_t last) {fZlast = last;}

   static TVirtualFitter *GetFitter();
   static TVirtualFitter *Fitter(TObject *obj, Int_t maxpar = 25);
   static const char *GetDefaultFitter();
   static Int_t GetMaxIterations();
   static Double_t GetErrorDef();
   static Double_t GetPrecision();
   static void SetDefaultFitter(const char* name = "");
   static void SetFitter(TVirtualFitter *fitter, Int_t maxpar = 25);
   static void SetMaxIterations(Int_t niter=5000);
   static void SetErrorDef(Double_t errdef=1);
   static void SetPrecision(Double_t prec=1e-6);

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TVirtualFitter::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TVirtualFitter::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualFitter.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 125; } //Abstract interface for fitting
};
# 36 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 1
// @(#)root/base:$Id: TObject.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 37 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 1
/* @(#)root/base:$Id: Rtypes.h 43708 2012-04-12 10:19:00Z axel $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 38 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNamed.h" 1
// @(#)root/base:$Id: TNamed.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 39 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TError.h" 1
// @(#)root/base:$Id: TError.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 40 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjArray.h" 1
// @(#)root/cont:$Id: TObjArray.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Fons Rademakers   11/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 41 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClonesArray.h" 1
// @(#)root/cont:$Id: TClonesArray.h 40562 2011-08-11 16:05:17Z pcanal $
// Author: Rene Brun   11/02/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/





//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TClonesArray                                                         //
//                                                                      //
// An array of clone TObjects. The array expands automatically when     //
// adding elements (shrinking can be done explicitly).                  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////





class TClass;


class TClonesArray : public TObjArray {

protected:
   TClass *fClass; //!Pointer to the class
   TObjArray *fKeep; //!Saved copies of pointers to objects

public:
   enum {
      kForgetBits = (1ULL << (0)), // Do not create branches for fBits, fUniqueID
      kNoSplit = (1ULL << (1)), // Array not split by TTree::Branch
      kBypassStreamer = (1ULL << (12)) // Class Streamer not called (default)
   };

   TClonesArray();
   TClonesArray(const char *classname, Int_t size = 1000, Bool_t call_dtor = kFALSE);
   TClonesArray(const TClass *cl, Int_t size = 1000, Bool_t call_dtor = kFALSE);
   TClonesArray(const TClonesArray& tc);
   virtual ~TClonesArray();
   TClonesArray& operator=(const TClonesArray& tc);
   virtual void Compress();
   virtual void Clear(Option_t *option="");
   virtual void Delete(Option_t *option="");
   virtual void Expand(Int_t newSize);
   virtual void ExpandCreate(Int_t n);
   virtual void ExpandCreateFast(Int_t n);
   TClass *GetClass() const { return fClass; }
   virtual void SetOwner(Bool_t enable = kTRUE);

   void AddFirst(TObject *) { MayNotUse("AddFirst"); }
   void AddLast(TObject *) { MayNotUse("AddLast"); }
   void AddAt(TObject *, Int_t) { MayNotUse("AddAt"); }
   void AddAtAndExpand(TObject *, Int_t) { MayNotUse("AddAtAndExpand"); }
   Int_t AddAtFree(TObject *) { MayNotUse("AddAtFree"); return 0; }
   void AddAfter(const TObject *, TObject *) { MayNotUse("AddAfter"); }
   void AddBefore(const TObject *, TObject *) { MayNotUse("AddBefore"); }
   void BypassStreamer(Bool_t bypass=kTRUE);
   Bool_t CanBypassStreamer() const { return TestBit(kBypassStreamer); }
   TObject *ConstructedAt(Int_t idx);
   TObject *ConstructedAt(Int_t idx, Option_t *clear_options);
   void SetClass(const char *classname,Int_t size=1000);
   void SetClass(const TClass *cl,Int_t size=1000);

   void AbsorbObjects(TClonesArray *tc);
   void AbsorbObjects(TClonesArray *tc, Int_t idx1, Int_t idx2);
   void MultiSort(Int_t nTCs, TClonesArray** tcs, Int_t upto = kMaxInt);
   virtual TObject *RemoveAt(Int_t idx);
   virtual TObject *Remove(TObject *obj);
   virtual void RemoveRange(Int_t idx1, Int_t idx2);
   virtual void Sort(Int_t upto = kMaxInt);

   TObject *New(Int_t idx);
   TObject *AddrAt(Int_t idx);
   TObject *&operator[](Int_t idx);
   TObject *operator[](Int_t idx) const;

   private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 4; } static void Dictionary(); virtual TClass *IsA() const { return TClonesArray::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TClonesArray::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClonesArray.h"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 87; } //An array of clone objects
};

inline TObject *TClonesArray::AddrAt(Int_t idx)
{
   return operator[](idx);
}
# 41 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 19 "/nfs/RAID/home/kamio/local/include/TGlobalLibs.hh" 2
using namespace std;

void Err(Int_t=0);
void Err(const Char_t*, Int_t=0);
void Err(const Char_t*, const Char_t*, Int_t=0);
Int_t ReadFileInit(ifstream &fin);
# 14 "./include/MDCSimulator.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TMCEvent.hh" 1


/**************************************************
 *  *** TMCEVENT_HH ***
 *  
 *  
 **************************************************/

# 1 "/nfs/RAID/home/kamio/local/include/TGlobalLibs.hh" 1
# 10 "/nfs/RAID/home/kamio/local/include/TMCEvent.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/ZNumDefine.h" 1



//--------------------------------------------------
const Int_t N_XY = 2;
const Int_t N_XYZ = 3;
enum EXY{kX=0, kY=1};
enum Exyz{kx=0, ky=1, kz=2};
enum EVolume{kNon=0,kCHD=1,kIMC=2,kTASC=3,kW=4};

//--------------------------------------------------

const Int_t N_CHD_XY = N_XY;
const Int_t N_CHD_BAR = 14;
const Int_t N_CHD_TOT = N_XY*N_CHD_BAR;

const Int_t N_IMC_XY = N_XY;
const Int_t N_IMC_LAYER = 8;
const Int_t N_IMC_FIBER = 448;
const Int_t N_IMC_TOT = (N_IMC_XY * N_IMC_LAYER * N_IMC_FIBER);

const Int_t N_W_LAYER = 7;
const Int_t N_W_TOT = N_W_LAYER;

const Int_t N_TASC_XY = N_XY;
const Int_t N_TASC_LAYER = 6;
const Int_t N_TASC_LOG = 16;
const Int_t N_TASC_TOT = (N_TASC_XY * N_TASC_LAYER * N_TASC_LOG);

const Int_t N_MAPMT_EACH = 14;
const Int_t N_MAPMT_LAYER = 4;
const Int_t N_MAPMT = (N_XY * N_MAPMT_EACH * N_MAPMT_LAYER);

//--------------------------------------------------
//const Int_t    N_COMP = 8505; //config_v3_7 & CALET_v3_8
const Int_t N_COMP = 23416; //config_v4_1
# 11 "/nfs/RAID/home/kamio/local/include/TMCEvent.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 1
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TApplication.h" 1
// @(#)root/base:$Id: TApplication.h 39402 2011-05-26 12:56:31Z axel $
// Author: Fons Rademakers   22/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 2 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFile.h" 1
// @(#)root/io:$Id: TFile.h 42754 2012-01-20 20:13:07Z pcanal $
// Author: Rene Brun   28/11/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 3 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h" 1
// @(#)root/hist:$Id: TF1.h 36906 2010-11-24 15:52:01Z moneta $
// Author: Rene Brun   18/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
// ---------------------------------- F1.h
# 4 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 1
// @(#)root/hist:$Id: TH1.h 44121 2012-05-04 14:44:59Z moneta $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 5 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h" 1
// @(#)root/hist:$Id: TH2.h 44515 2012-06-04 14:16:56Z moneta $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 6 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h" 1
// @(#)root/hist:$Id: TH3.h 44515 2012-06-04 14:16:56Z moneta $
// Author: Rene Brun   27/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 7 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph.h" 1
// @(#)root/hist:$Id: TGraph.h 38549 2011-03-21 19:26:04Z pcanal $
// Author: Rene Brun, Olivier Couet   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 8 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph2D.h" 1
// @(#)root/hist:$Id: TGraph2D.h,v 1.00
// Author: Olivier Couet

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 9 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 1
// @(#)root/tree:$Id: TNtuple.h 41666 2011-10-31 19:10:37Z pcanal $
// Author: Rene Brun   06/04/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 10 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TProfile.h" 1
// @(#)root/hist:$Id: TProfile.h 43802 2012-04-17 15:20:48Z moneta $
// Author: Rene Brun   29/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 11 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 1
// @(#)root/tree:$Id: TNtuple.h 41666 2011-10-31 19:10:37Z pcanal $
// Author: Rene Brun   06/04/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 12 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TRandom.h" 1
// @(#)root/mathcore:$Id: TRandom.h 32526 2010-03-10 14:56:13Z moneta $
// Author: Rene Brun   15/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 13 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvas.h" 1
// @(#)root/gpad:$Id: TCanvas.h 29403 2009-07-09 07:17:16Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 14 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLine.h" 1
// @(#)root/graf:$Id: TLine.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 15 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPaveLabel.h" 1
// @(#)root/graf:$Id: TPaveLabel.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   17/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 16 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGClient.h" 1
// @(#)root/gui:$Id: TGClient.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Fons Rademakers   27/12/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 17 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TStyle.h" 1
// @(#)root/base:$Id: TStyle.h 38506 2011-03-18 14:08:49Z couet $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 18 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h" 1
// @(#)root/base:$Id: TSystem.h 42099 2011-11-17 19:16:32Z rdm $
// Author: Fons Rademakers   15/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 19 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBox.h" 1
// @(#)root/graf:$Id: TBox.h 36489 2010-11-03 08:33:25Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 20 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TWbox.h" 1
// @(#)root/graf:$Id: TWbox.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 21 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TROOT.h" 1
// @(#)root/base:$Id: TROOT.h 42030 2011-11-15 22:23:12Z pcanal $
// Author: Rene Brun   08/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 22 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TButton.h" 1
// @(#)root/gpad:$Id: TButton.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   01/07/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 23 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TColor.h" 1
// @(#)root/base:$Id: TColor.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 24 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraphErrors.h" 1
// @(#)root/hist:$Id: TGraphErrors.h 24702 2008-07-08 12:01:46Z brun $
// Author: Rene Brun   15/09/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 25 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMarker.h" 1
// @(#)root/graf:$Id: TMarker.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/05/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 26 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h" 1
// @(#)root/mathcore:$Id: TMath.h 41837 2011-11-09 16:04:19Z rdm $
// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 27 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TText.h" 1
// @(#)root/graf:$Id: TText.h 33120 2010-04-21 14:29:04Z couet $
// Author: Nicolas Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 28 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h" 1
// @(#)root/tree:$Id: TTree.h 44280 2012-05-18 06:05:10Z pcanal $
// Author: Rene Brun   12/01/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 29 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLatex.h" 1
// @(#)root/graf:$Id: TLatex.h 33468 2010-05-11 14:09:36Z couet $
// Author: Nicolas Brun   07/08/98

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 30 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLegend.h" 1
// @(#)root/graf:$Id: TLegend.h 26711 2008-12-06 19:50:17Z brun $
// Author: Matthew.Adam.Dobbs   06/09/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
//--------------------------------------------------------------------------
# 31 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TChain.h" 1
// @(#)root/tree:$Id: TChain.h 42754 2012-01-20 20:13:07Z pcanal $
// Author: Rene Brun   03/02/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 32 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGaxis.h" 1
// @(#)root/graf:$Id: TGaxis.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun, Olivier Couet   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 33 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMultiGraph.h" 1
// @(#)root/hist:$Id: TMultiGraph.h 43622 2012-04-03 13:24:13Z couet $
// Author: Rene Brun   12/10/2000

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 34 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSpectrum.h" 1
// @(#)root/spectrum:$Id: TSpectrum.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Miroslav Morhac   27/05/99

/*************************************************************************
 * Copyright (C) 1995-2006, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 35 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualFitter.h" 1
// @(#)root/mathcore:$Id: TVirtualFitter.h 25927 2008-10-22 23:42:01Z rdm $
// Author: Rene Brun   31/08/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 36 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 1
// @(#)root/base:$Id: TObject.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 37 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 1
/* @(#)root/base:$Id: Rtypes.h 43708 2012-04-12 10:19:00Z axel $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 38 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNamed.h" 1
// @(#)root/base:$Id: TNamed.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 39 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TError.h" 1
// @(#)root/base:$Id: TError.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 40 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjArray.h" 1
// @(#)root/cont:$Id: TObjArray.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Fons Rademakers   11/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 41 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClonesArray.h" 1
// @(#)root/cont:$Id: TClonesArray.h 40562 2011-08-11 16:05:17Z pcanal $
// Author: Rene Brun   11/02/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 41 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 12 "/nfs/RAID/home/kamio/local/include/TMCEvent.hh" 2

# 1 "/nfs/RAID/home/kamio/local/include/TEnergyDeposit.hh" 1


/**************************************************
 *  *** TENERGYDEPOSIT_HH ***
 *  
 *  
 **************************************************/



# 1 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 1
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TApplication.h" 1
// @(#)root/base:$Id: TApplication.h 39402 2011-05-26 12:56:31Z axel $
// Author: Fons Rademakers   22/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 2 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFile.h" 1
// @(#)root/io:$Id: TFile.h 42754 2012-01-20 20:13:07Z pcanal $
// Author: Rene Brun   28/11/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 3 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h" 1
// @(#)root/hist:$Id: TF1.h 36906 2010-11-24 15:52:01Z moneta $
// Author: Rene Brun   18/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
// ---------------------------------- F1.h
# 4 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 1
// @(#)root/hist:$Id: TH1.h 44121 2012-05-04 14:44:59Z moneta $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 5 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h" 1
// @(#)root/hist:$Id: TH2.h 44515 2012-06-04 14:16:56Z moneta $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 6 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h" 1
// @(#)root/hist:$Id: TH3.h 44515 2012-06-04 14:16:56Z moneta $
// Author: Rene Brun   27/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 7 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph.h" 1
// @(#)root/hist:$Id: TGraph.h 38549 2011-03-21 19:26:04Z pcanal $
// Author: Rene Brun, Olivier Couet   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 8 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph2D.h" 1
// @(#)root/hist:$Id: TGraph2D.h,v 1.00
// Author: Olivier Couet

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 9 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 1
// @(#)root/tree:$Id: TNtuple.h 41666 2011-10-31 19:10:37Z pcanal $
// Author: Rene Brun   06/04/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 10 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TProfile.h" 1
// @(#)root/hist:$Id: TProfile.h 43802 2012-04-17 15:20:48Z moneta $
// Author: Rene Brun   29/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 11 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 1
// @(#)root/tree:$Id: TNtuple.h 41666 2011-10-31 19:10:37Z pcanal $
// Author: Rene Brun   06/04/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 12 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TRandom.h" 1
// @(#)root/mathcore:$Id: TRandom.h 32526 2010-03-10 14:56:13Z moneta $
// Author: Rene Brun   15/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 13 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvas.h" 1
// @(#)root/gpad:$Id: TCanvas.h 29403 2009-07-09 07:17:16Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 14 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLine.h" 1
// @(#)root/graf:$Id: TLine.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 15 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPaveLabel.h" 1
// @(#)root/graf:$Id: TPaveLabel.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   17/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 16 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGClient.h" 1
// @(#)root/gui:$Id: TGClient.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Fons Rademakers   27/12/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 17 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TStyle.h" 1
// @(#)root/base:$Id: TStyle.h 38506 2011-03-18 14:08:49Z couet $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 18 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h" 1
// @(#)root/base:$Id: TSystem.h 42099 2011-11-17 19:16:32Z rdm $
// Author: Fons Rademakers   15/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 19 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBox.h" 1
// @(#)root/graf:$Id: TBox.h 36489 2010-11-03 08:33:25Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 20 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TWbox.h" 1
// @(#)root/graf:$Id: TWbox.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 21 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TROOT.h" 1
// @(#)root/base:$Id: TROOT.h 42030 2011-11-15 22:23:12Z pcanal $
// Author: Rene Brun   08/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 22 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TButton.h" 1
// @(#)root/gpad:$Id: TButton.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   01/07/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 23 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TColor.h" 1
// @(#)root/base:$Id: TColor.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 24 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraphErrors.h" 1
// @(#)root/hist:$Id: TGraphErrors.h 24702 2008-07-08 12:01:46Z brun $
// Author: Rene Brun   15/09/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 25 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMarker.h" 1
// @(#)root/graf:$Id: TMarker.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/05/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 26 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h" 1
// @(#)root/mathcore:$Id: TMath.h 41837 2011-11-09 16:04:19Z rdm $
// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 27 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TText.h" 1
// @(#)root/graf:$Id: TText.h 33120 2010-04-21 14:29:04Z couet $
// Author: Nicolas Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 28 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h" 1
// @(#)root/tree:$Id: TTree.h 44280 2012-05-18 06:05:10Z pcanal $
// Author: Rene Brun   12/01/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 29 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLatex.h" 1
// @(#)root/graf:$Id: TLatex.h 33468 2010-05-11 14:09:36Z couet $
// Author: Nicolas Brun   07/08/98

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 30 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLegend.h" 1
// @(#)root/graf:$Id: TLegend.h 26711 2008-12-06 19:50:17Z brun $
// Author: Matthew.Adam.Dobbs   06/09/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
//--------------------------------------------------------------------------
# 31 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TChain.h" 1
// @(#)root/tree:$Id: TChain.h 42754 2012-01-20 20:13:07Z pcanal $
// Author: Rene Brun   03/02/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 32 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGaxis.h" 1
// @(#)root/graf:$Id: TGaxis.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun, Olivier Couet   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 33 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMultiGraph.h" 1
// @(#)root/hist:$Id: TMultiGraph.h 43622 2012-04-03 13:24:13Z couet $
// Author: Rene Brun   12/10/2000

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 34 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSpectrum.h" 1
// @(#)root/spectrum:$Id: TSpectrum.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Miroslav Morhac   27/05/99

/*************************************************************************
 * Copyright (C) 1995-2006, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 35 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualFitter.h" 1
// @(#)root/mathcore:$Id: TVirtualFitter.h 25927 2008-10-22 23:42:01Z rdm $
// Author: Rene Brun   31/08/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 36 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 1
// @(#)root/base:$Id: TObject.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 37 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 1
/* @(#)root/base:$Id: Rtypes.h 43708 2012-04-12 10:19:00Z axel $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 38 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNamed.h" 1
// @(#)root/base:$Id: TNamed.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 39 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TError.h" 1
// @(#)root/base:$Id: TError.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 40 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjArray.h" 1
// @(#)root/cont:$Id: TObjArray.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Fons Rademakers   11/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 41 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClonesArray.h" 1
// @(#)root/cont:$Id: TClonesArray.h 40562 2011-08-11 16:05:17Z pcanal $
// Author: Rene Brun   11/02/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 41 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 12 "/nfs/RAID/home/kamio/local/include/TEnergyDeposit.hh" 2
using namespace std;

class TEnergyDeposit : public TObject{
protected:

public:

 Int_t fID; // Volume ID
 Int_t fSubID; // Sub-volume ID
 Float_t fEDep; // Integrated energy release in the volume
 Float_t fEDepEff; // Effective energy release due to quenching, attenuation, etc.

public:
 TEnergyDeposit(){;}
 virtual ~TEnergyDeposit(){;}

 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TEnergyDeposit::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TEnergyDeposit::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TEnergyDeposit.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 28; }
};
# 14 "/nfs/RAID/home/kamio/local/include/TMCEvent.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TIncidentParticle.hh" 1


/**************************************************
 *  *** TINCIDENTPARTICLE_HH ***
 *  
 *  
 **************************************************/


# 1 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 1
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TApplication.h" 1
// @(#)root/base:$Id: TApplication.h 39402 2011-05-26 12:56:31Z axel $
// Author: Fons Rademakers   22/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 2 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFile.h" 1
// @(#)root/io:$Id: TFile.h 42754 2012-01-20 20:13:07Z pcanal $
// Author: Rene Brun   28/11/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 3 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h" 1
// @(#)root/hist:$Id: TF1.h 36906 2010-11-24 15:52:01Z moneta $
// Author: Rene Brun   18/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
// ---------------------------------- F1.h
# 4 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 1
// @(#)root/hist:$Id: TH1.h 44121 2012-05-04 14:44:59Z moneta $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 5 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h" 1
// @(#)root/hist:$Id: TH2.h 44515 2012-06-04 14:16:56Z moneta $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 6 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h" 1
// @(#)root/hist:$Id: TH3.h 44515 2012-06-04 14:16:56Z moneta $
// Author: Rene Brun   27/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 7 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph.h" 1
// @(#)root/hist:$Id: TGraph.h 38549 2011-03-21 19:26:04Z pcanal $
// Author: Rene Brun, Olivier Couet   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 8 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph2D.h" 1
// @(#)root/hist:$Id: TGraph2D.h,v 1.00
// Author: Olivier Couet

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 9 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 1
// @(#)root/tree:$Id: TNtuple.h 41666 2011-10-31 19:10:37Z pcanal $
// Author: Rene Brun   06/04/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 10 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TProfile.h" 1
// @(#)root/hist:$Id: TProfile.h 43802 2012-04-17 15:20:48Z moneta $
// Author: Rene Brun   29/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 11 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 1
// @(#)root/tree:$Id: TNtuple.h 41666 2011-10-31 19:10:37Z pcanal $
// Author: Rene Brun   06/04/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 12 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TRandom.h" 1
// @(#)root/mathcore:$Id: TRandom.h 32526 2010-03-10 14:56:13Z moneta $
// Author: Rene Brun   15/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 13 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvas.h" 1
// @(#)root/gpad:$Id: TCanvas.h 29403 2009-07-09 07:17:16Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 14 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLine.h" 1
// @(#)root/graf:$Id: TLine.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 15 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPaveLabel.h" 1
// @(#)root/graf:$Id: TPaveLabel.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   17/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 16 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGClient.h" 1
// @(#)root/gui:$Id: TGClient.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Fons Rademakers   27/12/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 17 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TStyle.h" 1
// @(#)root/base:$Id: TStyle.h 38506 2011-03-18 14:08:49Z couet $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 18 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h" 1
// @(#)root/base:$Id: TSystem.h 42099 2011-11-17 19:16:32Z rdm $
// Author: Fons Rademakers   15/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 19 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBox.h" 1
// @(#)root/graf:$Id: TBox.h 36489 2010-11-03 08:33:25Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 20 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TWbox.h" 1
// @(#)root/graf:$Id: TWbox.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 21 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TROOT.h" 1
// @(#)root/base:$Id: TROOT.h 42030 2011-11-15 22:23:12Z pcanal $
// Author: Rene Brun   08/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 22 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TButton.h" 1
// @(#)root/gpad:$Id: TButton.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   01/07/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 23 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TColor.h" 1
// @(#)root/base:$Id: TColor.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 24 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraphErrors.h" 1
// @(#)root/hist:$Id: TGraphErrors.h 24702 2008-07-08 12:01:46Z brun $
// Author: Rene Brun   15/09/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 25 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMarker.h" 1
// @(#)root/graf:$Id: TMarker.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/05/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 26 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h" 1
// @(#)root/mathcore:$Id: TMath.h 41837 2011-11-09 16:04:19Z rdm $
// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 27 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TText.h" 1
// @(#)root/graf:$Id: TText.h 33120 2010-04-21 14:29:04Z couet $
// Author: Nicolas Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 28 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h" 1
// @(#)root/tree:$Id: TTree.h 44280 2012-05-18 06:05:10Z pcanal $
// Author: Rene Brun   12/01/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 29 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLatex.h" 1
// @(#)root/graf:$Id: TLatex.h 33468 2010-05-11 14:09:36Z couet $
// Author: Nicolas Brun   07/08/98

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 30 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLegend.h" 1
// @(#)root/graf:$Id: TLegend.h 26711 2008-12-06 19:50:17Z brun $
// Author: Matthew.Adam.Dobbs   06/09/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
//--------------------------------------------------------------------------
# 31 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TChain.h" 1
// @(#)root/tree:$Id: TChain.h 42754 2012-01-20 20:13:07Z pcanal $
// Author: Rene Brun   03/02/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 32 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGaxis.h" 1
// @(#)root/graf:$Id: TGaxis.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun, Olivier Couet   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 33 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMultiGraph.h" 1
// @(#)root/hist:$Id: TMultiGraph.h 43622 2012-04-03 13:24:13Z couet $
// Author: Rene Brun   12/10/2000

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 34 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSpectrum.h" 1
// @(#)root/spectrum:$Id: TSpectrum.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Miroslav Morhac   27/05/99

/*************************************************************************
 * Copyright (C) 1995-2006, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 35 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualFitter.h" 1
// @(#)root/mathcore:$Id: TVirtualFitter.h 25927 2008-10-22 23:42:01Z rdm $
// Author: Rene Brun   31/08/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 36 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 1
// @(#)root/base:$Id: TObject.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 37 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 1
/* @(#)root/base:$Id: Rtypes.h 43708 2012-04-12 10:19:00Z axel $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 38 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNamed.h" 1
// @(#)root/base:$Id: TNamed.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 39 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TError.h" 1
// @(#)root/base:$Id: TError.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 40 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjArray.h" 1
// @(#)root/cont:$Id: TObjArray.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Fons Rademakers   11/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 41 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClonesArray.h" 1
// @(#)root/cont:$Id: TClonesArray.h 40562 2011-08-11 16:05:17Z pcanal $
// Author: Rene Brun   11/02/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 41 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 11 "/nfs/RAID/home/kamio/local/include/TIncidentParticle.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TCALGeometry.hh" 1


/**************************************************
 *  *** TCALGEOMETRY_HH ***
 *  
 *  
 *  fgConfigVer:
 *     Ver1: CALET_20110518ver. (CALET_v3.7)
 *     Ver2: CALET_20110831ver. (CALET_v4.1)
 *     Ver3: CALET_20120506ver. (CALET_v4.2)
 *     Ver5: CALET_20131103ver. (CALET_v5.1)
**************************************************/



using namespace std;


//const Int_t N_COMP = 23416;  //config_v4_1
//const Int_t N_COMP = 8505; //config_v3_7 & CALET_v3_8


class TCALGeometry{
public:

  static Int_t fgConfigVer;

  Float_t fPosCHD[N_XY][N_CHD_BAR][N_XYZ];
  Float_t fSizeCHD[N_XY][N_CHD_BAR][N_XYZ];
  Float_t fPosIMC[N_IMC_XY][N_IMC_LAYER][N_IMC_FIBER][N_XYZ];
  Float_t fSizeIMC[N_IMC_XY][N_IMC_LAYER][N_IMC_FIBER][N_XYZ];
  Float_t fPosTASC[N_TASC_XY][N_TASC_LAYER][N_TASC_LOG][N_XYZ];
  Float_t fSizeTASC[N_TASC_XY][N_TASC_LAYER][N_TASC_LOG][N_XYZ];
  Float_t fPosW[N_W_LAYER][N_XYZ];
  Float_t fSizeW[N_W_LAYER][N_XYZ];
  //
  TString fMedia[N_COMP]; //for read EPICS data


public:
  TCALGeometry();
  TCALGeometry(int);
  virtual ~TCALGeometry();

  virtual void ReadConfigTab();

  void SetPosCHD(Int_t xyz, Int_t xy, Int_t i, Float_t pos) { fPosCHD[xy][i][xyz] = pos; } // Set the origin of CHD
  void SetPosIMC(Int_t xyz, Int_t xy, Int_t i, Int_t j, Float_t pos) { fPosIMC[xy][i][j][xyz] = pos; } // Set the origin of SciFi
  void SetPosW(Int_t xyz, Int_t i, Float_t pos) { fPosW[i][xyz] = pos; } // Set the origin of W
  void SetPosTASC(Int_t xyz, Int_t xy, Int_t i, Int_t j, Float_t pos) { fPosTASC[xy][i][j][xyz] = pos; } // Set the origin of TASC
  void SetSizeCHD(Int_t xyz, Int_t xy, Int_t i, Float_t size) { fSizeCHD[xy][i][xyz] = size; } // Set the size of CHD
  void SetSizeIMC(Int_t xyz, Int_t xy, Int_t i, Int_t j, Float_t size) { fSizeIMC[xy][i][j][xyz] = size; } // Set the size of SciFi
  void SetSizeW(Int_t xyz, Int_t i, Float_t size) { fSizeW[i][xyz] = size; } // Set the size of W
  void SetSizeTASC(Int_t xyz, Int_t xy, Int_t i, Int_t j, Float_t size){ fSizeTASC[xy][i][j][xyz] = size; } // Set the size of TASC

  Float_t PosCHD(Int_t xyz, Int_t xy, Int_t i) { return fPosCHD[xy][i][xyz]; } // coord. of low edge of CHD
  Float_t PosIMC(Int_t xyz, Int_t xy, Int_t i, Int_t j) { return fPosIMC[xy][i][j][xyz]; } // coord. of low edge of IMC
  Float_t PosW(Int_t xyz, Int_t i) { return fPosW[i][xyz]; } // coord. of low edge of W
  Float_t PosTASC(Int_t xyz, Int_t xy, Int_t i, Int_t j) { return fPosTASC[xy][i][j][xyz]; } // coord. of low edge of TASC

  Float_t PosCCHD(Int_t xyz, Int_t xy, Int_t i) { return fPosCHD[xy][i][xyz] + fSizeCHD[xy][i][xyz]/2.0; } // coord. of center of CHD
  Float_t PosCIMC(Int_t xyz, Int_t xy, Int_t i, Int_t j) { return fPosIMC[xy][i][j][xyz] + fSizeIMC[xy][i][j][xyz]/2.0; } // coord. of center of IMC
  Float_t PosCW(Int_t xyz, Int_t i) { return fPosW[i][xyz] + fSizeW[i][xyz]/2.0; } // coord. of center of W
  Float_t PosCTASC(Int_t xyz, Int_t xy, Int_t i, Int_t j) { return fPosTASC[xy][i][j][xyz] + fSizeTASC[xy][i][j][xyz]/2.0; } // coord. of center of TASC
  Float_t PosECHD(Int_t xyz, Int_t xy, Int_t i) { return fPosCHD[xy][i][xyz] + fSizeCHD[xy][i][xyz]; } // coord. of end of CHD
  Float_t PosEIMC(Int_t xyz, Int_t xy, Int_t i, Int_t j) { return fPosIMC[xy][i][j][xyz] + fSizeIMC[xy][i][j][xyz]; } // coord. of end of IMC
  Float_t PosEW(Int_t xyz, Int_t i) { return fPosW[i][xyz] + fSizeW[i][xyz]; } // coord. of end of W
  Float_t PosETASC(Int_t xyz, Int_t xy, Int_t i, Int_t j) { return fPosTASC[xy][i][j][xyz] + fSizeTASC[xy][i][j][xyz]; } // coord. of end of TASC

  Float_t SizeCHD(Int_t xyz, Int_t xy, Int_t i) { return fSizeCHD[xy][i][xyz]; } //  size of CHD
  Float_t SizeIMC(Int_t xyz, Int_t xy, Int_t i, Int_t j) { return fSizeIMC[xy][i][j][xyz]; } //  size of IMC
  Float_t SizeW(Int_t xyz, Int_t i) { return fSizeW[i][xyz]; } //  size of W
  Float_t SizeTASC(Int_t xyz, Int_t xy, Int_t i, Int_t j) { return fSizeTASC[xy][i][j][xyz]; } //  size of TASC

  Float_t *PosCHD(Int_t xy, Int_t i) { return fPosCHD[xy][i]; } // Get P coord. of low edge of CHD
  Float_t *PosIMC(Int_t xy, Int_t i, Int_t j) { return fPosIMC[xy][i][j]; } // Get P coord. of low edge of IMC
  Float_t *PosW(Int_t i) { return fPosW[i]; } // Get P coord. of low edge of W
  Float_t *PosTASC(Int_t xy, Int_t i, Int_t j) { return fPosTASC[xy][i][j]; } // Get P coord. of low edge of TASC

  Float_t *SizeCHD(Int_t xy, Int_t i) { return fSizeCHD[xy][i]; } // Get P size of CHD
  Float_t *SizeIMC(Int_t xy, Int_t i, Int_t j) { return fSizeIMC[xy][i][j]; } // Get P size of IMC
  Float_t *SizeW(Int_t i) { return fSizeW[i]; } // Get P size of W
  Float_t *SizeTASC(Int_t xy, Int_t i, Int_t j) { return fSizeTASC[xy][i][j]; } // Get P size of TASC

  void SetMedia(Int_t cn, TString media) {fMedia[cn] = media;}
  TString Media(Int_t cn) {return fMedia[cn];}


protected:
  Int_t read_cnfg1(ifstream&);
  Int_t read_cnfg2(ifstream&);
  Int_t read_cnfg3(ifstream&);
  Int_t read_cnfg4(ifstream&);
  Int_t read_cnfg5(ifstream&);


  private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TCALGeometry::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TCALGeometry::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TCALGeometry.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 97; }
};
extern TCALGeometry *gGeo;
# 12 "/nfs/RAID/home/kamio/local/include/TIncidentParticle.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TInteractionInfo.hh" 1


/**************************************************
 *  *** TINTERACTIONINFO_HH ***
 *  
 *  
 **************************************************/



using namespace std;

class TInteractionInfo : public TObject{
public:

 Float_t fPos[N_XYZ]; //[N_XYZ] -collision or conversion position
 TObjString fProc; // -colision process "pair", "coll"
 TObjString fMedia; // -collision media, (SCIN, SF, W, PWO)
 Int_t fColA; // -mass number of target
 Int_t fColZ; // -z of target

public:
 TInteractionInfo();
 virtual ~TInteractionInfo();

 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TInteractionInfo::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TInteractionInfo::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TInteractionInfo.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 26; }
};
# 13 "/nfs/RAID/home/kamio/local/include/TIncidentParticle.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TCosmicInfo.hh" 1


/**************************************************
 *  *** TCOSMICINFO_HH ***
 *  
 *  
 **************************************************/


# 1 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 1
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TApplication.h" 1
// @(#)root/base:$Id: TApplication.h 39402 2011-05-26 12:56:31Z axel $
// Author: Fons Rademakers   22/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 2 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFile.h" 1
// @(#)root/io:$Id: TFile.h 42754 2012-01-20 20:13:07Z pcanal $
// Author: Rene Brun   28/11/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 3 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h" 1
// @(#)root/hist:$Id: TF1.h 36906 2010-11-24 15:52:01Z moneta $
// Author: Rene Brun   18/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
// ---------------------------------- F1.h
# 4 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 1
// @(#)root/hist:$Id: TH1.h 44121 2012-05-04 14:44:59Z moneta $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 5 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h" 1
// @(#)root/hist:$Id: TH2.h 44515 2012-06-04 14:16:56Z moneta $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 6 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h" 1
// @(#)root/hist:$Id: TH3.h 44515 2012-06-04 14:16:56Z moneta $
// Author: Rene Brun   27/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 7 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph.h" 1
// @(#)root/hist:$Id: TGraph.h 38549 2011-03-21 19:26:04Z pcanal $
// Author: Rene Brun, Olivier Couet   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 8 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph2D.h" 1
// @(#)root/hist:$Id: TGraph2D.h,v 1.00
// Author: Olivier Couet

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 9 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 1
// @(#)root/tree:$Id: TNtuple.h 41666 2011-10-31 19:10:37Z pcanal $
// Author: Rene Brun   06/04/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 10 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TProfile.h" 1
// @(#)root/hist:$Id: TProfile.h 43802 2012-04-17 15:20:48Z moneta $
// Author: Rene Brun   29/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 11 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 1
// @(#)root/tree:$Id: TNtuple.h 41666 2011-10-31 19:10:37Z pcanal $
// Author: Rene Brun   06/04/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 12 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TRandom.h" 1
// @(#)root/mathcore:$Id: TRandom.h 32526 2010-03-10 14:56:13Z moneta $
// Author: Rene Brun   15/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 13 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvas.h" 1
// @(#)root/gpad:$Id: TCanvas.h 29403 2009-07-09 07:17:16Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 14 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLine.h" 1
// @(#)root/graf:$Id: TLine.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 15 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPaveLabel.h" 1
// @(#)root/graf:$Id: TPaveLabel.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   17/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 16 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGClient.h" 1
// @(#)root/gui:$Id: TGClient.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Fons Rademakers   27/12/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 17 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TStyle.h" 1
// @(#)root/base:$Id: TStyle.h 38506 2011-03-18 14:08:49Z couet $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 18 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h" 1
// @(#)root/base:$Id: TSystem.h 42099 2011-11-17 19:16:32Z rdm $
// Author: Fons Rademakers   15/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 19 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBox.h" 1
// @(#)root/graf:$Id: TBox.h 36489 2010-11-03 08:33:25Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 20 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TWbox.h" 1
// @(#)root/graf:$Id: TWbox.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 21 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TROOT.h" 1
// @(#)root/base:$Id: TROOT.h 42030 2011-11-15 22:23:12Z pcanal $
// Author: Rene Brun   08/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 22 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TButton.h" 1
// @(#)root/gpad:$Id: TButton.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   01/07/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 23 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TColor.h" 1
// @(#)root/base:$Id: TColor.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 24 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraphErrors.h" 1
// @(#)root/hist:$Id: TGraphErrors.h 24702 2008-07-08 12:01:46Z brun $
// Author: Rene Brun   15/09/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 25 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMarker.h" 1
// @(#)root/graf:$Id: TMarker.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/05/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 26 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h" 1
// @(#)root/mathcore:$Id: TMath.h 41837 2011-11-09 16:04:19Z rdm $
// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 27 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TText.h" 1
// @(#)root/graf:$Id: TText.h 33120 2010-04-21 14:29:04Z couet $
// Author: Nicolas Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 28 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h" 1
// @(#)root/tree:$Id: TTree.h 44280 2012-05-18 06:05:10Z pcanal $
// Author: Rene Brun   12/01/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 29 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLatex.h" 1
// @(#)root/graf:$Id: TLatex.h 33468 2010-05-11 14:09:36Z couet $
// Author: Nicolas Brun   07/08/98

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 30 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLegend.h" 1
// @(#)root/graf:$Id: TLegend.h 26711 2008-12-06 19:50:17Z brun $
// Author: Matthew.Adam.Dobbs   06/09/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
//--------------------------------------------------------------------------
# 31 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TChain.h" 1
// @(#)root/tree:$Id: TChain.h 42754 2012-01-20 20:13:07Z pcanal $
// Author: Rene Brun   03/02/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 32 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGaxis.h" 1
// @(#)root/graf:$Id: TGaxis.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun, Olivier Couet   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 33 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMultiGraph.h" 1
// @(#)root/hist:$Id: TMultiGraph.h 43622 2012-04-03 13:24:13Z couet $
// Author: Rene Brun   12/10/2000

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 34 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSpectrum.h" 1
// @(#)root/spectrum:$Id: TSpectrum.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Miroslav Morhac   27/05/99

/*************************************************************************
 * Copyright (C) 1995-2006, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 35 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualFitter.h" 1
// @(#)root/mathcore:$Id: TVirtualFitter.h 25927 2008-10-22 23:42:01Z rdm $
// Author: Rene Brun   31/08/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 36 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 1
// @(#)root/base:$Id: TObject.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 37 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 1
/* @(#)root/base:$Id: Rtypes.h 43708 2012-04-12 10:19:00Z axel $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 38 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNamed.h" 1
// @(#)root/base:$Id: TNamed.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 39 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TError.h" 1
// @(#)root/base:$Id: TError.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 40 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjArray.h" 1
// @(#)root/cont:$Id: TObjArray.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Fons Rademakers   11/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 41 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClonesArray.h" 1
// @(#)root/cont:$Id: TClonesArray.h 40562 2011-08-11 16:05:17Z pcanal $
// Author: Rene Brun   11/02/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 41 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 11 "/nfs/RAID/home/kamio/local/include/TCosmicInfo.hh" 2
using namespace std;

class TCosmicInfo : public TObject{
public:

 Double_t fTime; // -from 1970/01/01/00:00:00
 Double_t fRA; // -[deg] Right Ascention        
 Double_t fDec; // -[deg] Declination
 TObjString fStar; // -Name of the source star
//
 Double_t fAltitude; // -[m] an altitude of ISS
 Double_t fLongitude; // -
 Double_t fLatitude; // -
 Double_t fAttitude[3]; // -[deg] Eular angle of CALET. Equinox is +x direction.

public:
 TCosmicInfo();
 virtual ~TCosmicInfo();

 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TCosmicInfo::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TCosmicInfo::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TCosmicInfo.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 30; }
};
# 14 "/nfs/RAID/home/kamio/local/include/TIncidentParticle.hh" 2
using namespace std;

class TIncidentParticle : public TObject{
protected:

public:

 Long_t fPdgCode; //  -PDGcode
 Float_t fKE; //  -[GeV] Kinetic Energy
 Float_t fPos[N_XYZ]; //[N_XYZ]  -[cm] position
 Float_t fDir[N_XYZ]; //[N_XYZ]  -direction cosine
//
 TInteractionInfo *fIntInfo; //-> -Info. about 1st interaction
 TCosmicInfo *fCosInfo; //-> -Info. about ...

public:
 TIncidentParticle();
 virtual ~TIncidentParticle();
//
 void InitAll();

 Long_t GetPdgCode() {return fPdgCode;}
 Float_t GetKE() {return fKE;}
 Float_t *GetPos() {return fPos;}
 Float_t GetPos(int xyz) {return fPos[xyz];}
 Float_t *GetDir() {return fDir;}
 Float_t GetDir(int xyz) {return fDir[xyz];}

 TInteractionInfo *GetIntInfo(){return fIntInfo;}
 TCosmicInfo *GetCosInfo(){return fCosInfo;}

 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TIncidentParticle::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TIncidentParticle::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TIncidentParticle.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 45; }
};
# 15 "/nfs/RAID/home/kamio/local/include/TMCEvent.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TMCSeedEPICS.hh" 1


/**************************************************
 *  *** TMCSEEDEPICS_HH ***
 *  
 *  
 **************************************************/


using namespace std;

class TMCSeedEPICS : public TObject{
public:
 Long_t fSeed1; // -Ir(1)
 Long_t fSeed2; // -Ir(2)
 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TMCSeedEPICS::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TMCSeedEPICS::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TMCSeedEPICS.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 16; };
};
# 16 "/nfs/RAID/home/kamio/local/include/TMCEvent.hh" 2

# 1 "/nfs/RAID/home/kamio/local/include/TVolumeID.hh" 1


/**************************************************
 *  *** TVOLUMEID_HH ***
 *  
 *  
 **************************************************/


# 1 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 1
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TApplication.h" 1
// @(#)root/base:$Id: TApplication.h 39402 2011-05-26 12:56:31Z axel $
// Author: Fons Rademakers   22/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 2 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TFile.h" 1
// @(#)root/io:$Id: TFile.h 42754 2012-01-20 20:13:07Z pcanal $
// Author: Rene Brun   28/11/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 3 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TF1.h" 1
// @(#)root/hist:$Id: TF1.h 36906 2010-11-24 15:52:01Z moneta $
// Author: Rene Brun   18/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
// ---------------------------------- F1.h
# 4 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH1.h" 1
// @(#)root/hist:$Id: TH1.h 44121 2012-05-04 14:44:59Z moneta $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 5 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH2.h" 1
// @(#)root/hist:$Id: TH2.h 44515 2012-06-04 14:16:56Z moneta $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 6 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TH3.h" 1
// @(#)root/hist:$Id: TH3.h 44515 2012-06-04 14:16:56Z moneta $
// Author: Rene Brun   27/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 7 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph.h" 1
// @(#)root/hist:$Id: TGraph.h 38549 2011-03-21 19:26:04Z pcanal $
// Author: Rene Brun, Olivier Couet   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 8 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraph2D.h" 1
// @(#)root/hist:$Id: TGraph2D.h,v 1.00
// Author: Olivier Couet

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 9 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 1
// @(#)root/tree:$Id: TNtuple.h 41666 2011-10-31 19:10:37Z pcanal $
// Author: Rene Brun   06/04/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 10 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TProfile.h" 1
// @(#)root/hist:$Id: TProfile.h 43802 2012-04-17 15:20:48Z moneta $
// Author: Rene Brun   29/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 11 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNtuple.h" 1
// @(#)root/tree:$Id: TNtuple.h 41666 2011-10-31 19:10:37Z pcanal $
// Author: Rene Brun   06/04/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 12 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TRandom.h" 1
// @(#)root/mathcore:$Id: TRandom.h 32526 2010-03-10 14:56:13Z moneta $
// Author: Rene Brun   15/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 13 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TCanvas.h" 1
// @(#)root/gpad:$Id: TCanvas.h 29403 2009-07-09 07:17:16Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 14 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLine.h" 1
// @(#)root/graf:$Id: TLine.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 15 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TPaveLabel.h" 1
// @(#)root/graf:$Id: TPaveLabel.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   17/10/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 16 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGClient.h" 1
// @(#)root/gui:$Id: TGClient.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Fons Rademakers   27/12/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 17 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TStyle.h" 1
// @(#)root/base:$Id: TStyle.h 38506 2011-03-18 14:08:49Z couet $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 18 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSystem.h" 1
// @(#)root/base:$Id: TSystem.h 42099 2011-11-17 19:16:32Z rdm $
// Author: Fons Rademakers   15/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 19 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TBox.h" 1
// @(#)root/graf:$Id: TBox.h 36489 2010-11-03 08:33:25Z brun $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 20 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TWbox.h" 1
// @(#)root/graf:$Id: TWbox.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 21 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TROOT.h" 1
// @(#)root/base:$Id: TROOT.h 42030 2011-11-15 22:23:12Z pcanal $
// Author: Rene Brun   08/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 22 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TButton.h" 1
// @(#)root/gpad:$Id: TButton.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   01/07/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 23 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TColor.h" 1
// @(#)root/base:$Id: TColor.h 43719 2012-04-12 23:00:08Z rdm $
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 24 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGraphErrors.h" 1
// @(#)root/hist:$Id: TGraphErrors.h 24702 2008-07-08 12:01:46Z brun $
// Author: Rene Brun   15/09/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 25 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMarker.h" 1
// @(#)root/graf:$Id: TMarker.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun   12/05/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 26 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMath.h" 1
// @(#)root/mathcore:$Id: TMath.h 41837 2011-11-09 16:04:19Z rdm $
// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 27 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TText.h" 1
// @(#)root/graf:$Id: TText.h 33120 2010-04-21 14:29:04Z couet $
// Author: Nicolas Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 28 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TTree.h" 1
// @(#)root/tree:$Id: TTree.h 44280 2012-05-18 06:05:10Z pcanal $
// Author: Rene Brun   12/01/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 29 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLatex.h" 1
// @(#)root/graf:$Id: TLatex.h 33468 2010-05-11 14:09:36Z couet $
// Author: Nicolas Brun   07/08/98

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 30 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TLegend.h" 1
// @(#)root/graf:$Id: TLegend.h 26711 2008-12-06 19:50:17Z brun $
// Author: Matthew.Adam.Dobbs   06/09/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
//--------------------------------------------------------------------------
# 31 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TChain.h" 1
// @(#)root/tree:$Id: TChain.h 42754 2012-01-20 20:13:07Z pcanal $
// Author: Rene Brun   03/02/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 32 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TGaxis.h" 1
// @(#)root/graf:$Id: TGaxis.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Rene Brun, Olivier Couet   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 33 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TMultiGraph.h" 1
// @(#)root/hist:$Id: TMultiGraph.h 43622 2012-04-03 13:24:13Z couet $
// Author: Rene Brun   12/10/2000

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 34 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TSpectrum.h" 1
// @(#)root/spectrum:$Id: TSpectrum.h 20882 2007-11-19 11:31:26Z rdm $
// Author: Miroslav Morhac   27/05/99

/*************************************************************************
 * Copyright (C) 1995-2006, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 35 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TVirtualFitter.h" 1
// @(#)root/mathcore:$Id: TVirtualFitter.h 25927 2008-10-22 23:42:01Z rdm $
// Author: Rene Brun   31/08/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 36 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObject.h" 1
// @(#)root/base:$Id: TObject.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 37 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/Rtypes.h" 1
/* @(#)root/base:$Id: Rtypes.h 43708 2012-04-12 10:19:00Z axel $ */

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 38 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TNamed.h" 1
// @(#)root/base:$Id: TNamed.h 20877 2007-11-19 11:17:07Z rdm $
// Author: Rene Brun   26/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 39 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TError.h" 1
// @(#)root/base:$Id: TError.h 38832 2011-04-13 17:54:49Z rdm $
// Author: Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 40 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TObjArray.h" 1
// @(#)root/cont:$Id: TObjArray.h 43515 2012-03-27 21:15:53Z pcanal $
// Author: Fons Rademakers   11/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 41 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 1 "/nfs/RAID/opt/root/v5.34.01_sl61/include/TClonesArray.h" 1
// @(#)root/cont:$Id: TClonesArray.h 40562 2011-08-11 16:05:17Z pcanal $
// Author: Rene Brun   11/02/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
# 41 "/nfs/RAID/home/kamio/local/include/ZRoot.h" 2
# 11 "/nfs/RAID/home/kamio/local/include/TVolumeID.hh" 2

using namespace std;

class TVolumeID : public TObject{
public:

 static Int_t fgVer;

public:
 TVolumeID();
 virtual ~TVolumeID();
//
 void Initialize();
 void GetID2Each(EVolume media, Int_t id, Int_t *i1=0, Int_t *i2=0, Int_t *i3=0);
 void GetEach2ID(EVolume media, Int_t *id, Int_t i1, Int_t i2=-1, Int_t i3=-1);

protected:


 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TVolumeID::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TVolumeID::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TVolumeID.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 30; }
};
extern TVolumeID *gVID;
# 18 "/nfs/RAID/home/kamio/local/include/TMCEvent.hh" 2
//#include "TCALData.hh"

using namespace std;

class TMCEvent : public TObject{
protected:

public:

 Int_t fN; // -Event number
 TIncidentParticle *fInci; //-> Incident Particle
//
 TMCSeedEPICS *fSeedEPICS; // -Seed of EPICS
//	TMCSeedG4    *fSeedG4;      // -Seed of G4
//	TMCSeedFluka *fSeedFluka;   // -Seed of Fluka
//
 TClonesArray *_fEDepCHD; //-> CHD
 TClonesArray *_fEDepIMC; //-> IMC
 TClonesArray *_fEDepTASC; //-> TASC
 TClonesArray *_fEDepW; //-> IMC(W)
//
 Float_t fENOut[3]; //[3] -Energy of nertral particles which escapes the detector from
 Float_t fECOut[3]; //[3] -Energy of charged particles which escapes
 Float_t fEBalance[12]; //[12] -(Fluka?)

public:
 TMCEvent();
 virtual ~TMCEvent();
//
 void InitAll();
//
 TIncidentParticle *GetInci(){ return fInci;} //

 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TMCEvent::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TMCEvent::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TMCEvent.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 51; }
};
# 15 "./include/MDCSimulator.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TDisplay.hh" 1


/**************************************************
 *  *** TDISPLAY_HH ***
 *  
 *  
 **************************************************/


# 1 "/nfs/RAID/home/kamio/local/include/TCALData.hh" 1


/**************************************************
 *  *** TCALDATA_HH ***
 *  
 *  
 **************************************************/



using namespace std;


class TCALData : public TObject{
public:
 Float_t fEDepCHD[N_CHD_XY][N_CHD_BAR]; //
 Float_t fEDepIMC[N_IMC_XY][N_IMC_LAYER][N_IMC_FIBER]; //
 Float_t fEDepTASC[N_TASC_XY][N_TASC_LAYER][N_TASC_LOG]; //
 Float_t fEDepW[N_W_LAYER]; //

public:
 TCALData();
 virtual ~TCALData();
//
 void Clear();
 void SetEDepCHD(Int_t xy, Int_t i, Float_t E){fEDepCHD[xy][i] = E;}
 void SetEDepIMC(Int_t xy, Int_t i, Int_t j, Float_t E){fEDepIMC[xy][i][j] = E;}
 void SetEDepTASC(Int_t xy, Int_t i, Int_t j, Float_t E){fEDepTASC[xy][i][j] = E;}
 void SetEDepW(Int_t i, Float_t E) {fEDepW[i] = E;}

 Float_t EDepCHD();
 Float_t EDepCHD(Int_t xy);
 Float_t EDepCHD(Int_t xy, Int_t i){return fEDepCHD[xy][i];}
 Float_t EDepIMC();
 Float_t EDepIMC(Int_t i);
 Float_t EDepIMC(Int_t xy, Int_t i);
 Float_t EDepIMC(Int_t xy, Int_t i, Int_t j){return fEDepIMC[xy][i][j];}
 Float_t EDepTASC();
 Float_t EDepTASC(Int_t xy, Int_t i);
 Float_t EDepTASC(Int_t xy, Int_t i, Int_t j){return fEDepTASC[xy][i][j];}

 Float_t EDepW();
 Float_t EDepW(Int_t i) {return fEDepW[i];};


 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 1; } static void Dictionary(); virtual TClass *IsA() const { return TCALData::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TCALData::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TCALData.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 46; }
};
# 11 "/nfs/RAID/home/kamio/local/include/TDisplay.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TDispDet.hh" 1


/**************************************************
 *  *** TDISPDET_HH ***
 *  
 *  
 **************************************************/



# 1 "/nfs/RAID/home/kamio/local/include/ZOneMIP.h" 1



// landau peak from mu+_2GeV(2011.3.21)
//  vertical
const Double_t MIP_CHD = 0.00165996;
const Double_t MIP_IMC = 0.000144761;
const Double_t MIP_TASC = 0.0204673;
/*
// landau peak from mu+_2GeV (2011.2.22)
const Double_t  MIP_CHD = 0.00177415;
const Double_t  MIP_SF  = 0.000152873;
const Double_t  MIP_PWO = 0.0215086;
*/
# 12 "/nfs/RAID/home/kamio/local/include/TDispDet.hh" 2
using namespace std;

class TDispDet : public TObject{
protected:

 TCALData *fD;
 TCanvas *fCanv;
 TPad *fPad[N_XY];
 TBox *mCHD[N_CHD_XY][N_CHD_BAR];
 TBox *mIMC[N_IMC_XY][N_IMC_LAYER][N_IMC_FIBER];
 TBox *mW[N_XY][N_W_LAYER];
 TBox *mTASC[N_TASC_XY][N_TASC_LAYER][N_TASC_LOG];

public:
 TCanvas* GetCanvas(){return fCanv;}
 TPad* GetCanvas(Int_t xy){return fPad[xy];}

public:
 TDispDet();
 TDispDet(TCALData*);
 virtual ~TDispDet();
//
 void SetCALData(TCALData *D){fD = D;}
 virtual void Initialize();
 virtual void InitDraw();
 virtual void DrawWindow();
 virtual void DrawUpdate();
 //

protected:
 Int_t color(Float_t);

 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TDispDet::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TDispDet::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TDispDet.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 44; }
};
# 12 "/nfs/RAID/home/kamio/local/include/TDisplay.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TDispCHD.hh" 1


/**************************************************
 *  *** TDISPCHD_HH ***
 *  
 *   y-value is MIP, not dE
 *   error is 0.
 **************************************************/




using namespace std;

class TDispCHD : public TObject{
protected:
 TCALData *fD;
 TCanvas *fCanv;
 TGraphErrors *fg_CHD[N_CHD_XY];

public:
 TDispCHD();
 TDispCHD(TCALData*);
 virtual ~TDispCHD();

 void SetCALData(TCALData* D){fD = D;}
 void Initialize();
 void InitDraw();
 void DrawWindow();
 void DrawUpdate();

 TCanvas *GetCanvas(){return fCanv;}

 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TDispCHD::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TDispCHD::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TDispCHD.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 34; }
};
# 13 "/nfs/RAID/home/kamio/local/include/TDisplay.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TDispIMC.hh" 1


/**************************************************
 *  *** TDISPIMC_HH ***
 *  
 *   y-value is MIP, not dE
 *   error is 0.
 **************************************************/




using namespace std;


class TDispIMC : public TObject{
protected:
 TCALData *fD;
  TCanvas *fCanv;
  TGraphErrors *fg_IMC[N_IMC_XY][N_IMC_LAYER];

public:
  TDispIMC();
  TDispIMC(TCALData*);
  virtual ~TDispIMC();

 void SetCALData(TCALData* D){fD = D;}
  void Initialize();
  void InitDraw();
  void DrawWindow();
  void DrawUpdate();

  TCanvas *GetCanvas(){return fCanv;}


  private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TDispIMC::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TDispIMC::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TDispIMC.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 36; }
};
# 14 "/nfs/RAID/home/kamio/local/include/TDisplay.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TDispTASC.hh" 1


/**************************************************
 *  *** TDISPTASC_HH ***
 *  
 *   y-value is MIP, not dE
 *   error is 0.
 **************************************************/




using namespace std;

class TDispTASC : public TObject{
protected:
 TCALData *fD;
 TCanvas *fCanv;
 TGraphErrors *fg_TASC[N_TASC_XY][N_TASC_LOG];

public:
 TDispTASC();
 TDispTASC(TCALData*);
 virtual ~TDispTASC();

 void SetCALData(TCALData* D){fD = D;}
 void Initialize();
 void InitDraw();
 void DrawWindow();
 void DrawUpdate();

 TCanvas *GetCanvas(){return fCanv;}


 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TDispTASC::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TDispTASC::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TDispTASC.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 35; }
};
# 15 "/nfs/RAID/home/kamio/local/include/TDisplay.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TDispDetv.hh" 1


/**************************************************
 *  *** TDISPDETV_HH ***
 *  
 *  
 **************************************************/




using namespace std;

class TDispDetv : public TObject{
protected:

 TCALData *fD;
 TCanvas *fCanv;
 TPad *fPad[N_XY];
 TBox *mCHD[N_CHD_XY][N_CHD_BAR];
 TBox *mIMC[N_IMC_XY][N_IMC_LAYER][N_IMC_FIBER];
 TBox *mW[N_XY][N_W_LAYER];
 TBox *mTASC[N_TASC_XY][N_TASC_LAYER][N_TASC_LOG];

public:
 TCanvas* GetCanvas(){return fCanv;}
 TPad* GetCanvas(Int_t xy){return fPad[xy];}

public:
 TDispDetv();
 TDispDetv(TCALData*);
 virtual ~TDispDetv();
//
 void SetCALData(TCALData* D){fD = D;}
 virtual void Initialize();
 virtual void InitDraw();
 virtual void DrawWindow();
 virtual void DrawUpdate();
 //

protected:
 Int_t color(Float_t);

 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TDispDetv::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TDispDetv::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TDispDetv.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 44; }
};
# 16 "/nfs/RAID/home/kamio/local/include/TDisplay.hh" 2
using namespace std;

const Int_t DISPBIT_DET = 0x01;
const Int_t DISPBIT_CHD = 0x02;
const Int_t DISPBIT_IMC = 0x04;
const Int_t DISPBIT_TASC = 0x08;
const Int_t DISPBIT_DETV = 0x10;
const Int_t DISPBIT_TRANS = 0x20;

class TDisplay : public TObject{
protected:

 TCALData *fD;
//
 TDispDet *fDispDet;
 TDispCHD *fDispCHD;
 TDispIMC *fDispIMC;
 TDispTASC *fDispTASC;
 TDispDetv *fDispDetv;
//  TDispTrans *fDispTrans;

public:
 TDisplay();
 TDisplay(TCALData*, Int_t);
 virtual ~TDisplay();
//
 void Initialize();
 void SetCALData(TCALData*);
 void SetViewer();
 void DrawWindows();
 void DrawUpdate();
 void DrawImage();
//
 TDispDet *GetDet() {return fDispDet;}

 TDispCHD *GetCHD() {return fDispCHD;}
 TDispIMC *GetIMC() {return fDispIMC;}
 TDispTASC *GetTASC() {return fDispTASC;}
 TDispDetv *GetDetv() {return fDispDetv;}

protected:
 Int_t fBitDraw;

 TCanvas *fCanvButton;
 TButton *fButton;

 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TDisplay::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TDisplay::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TDisplay.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 62; }
};
extern TDisplay *gDisp;
# 16 "./include/MDCSimulator.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TYACALData.hh" 1


/**************************************************
 *  *** TYACALDATA_HH ***
 *  
 *  
 **************************************************/



using namespace std;

class TYACALData : public TCALData{
public:

 Float_t fNmipCHD[N_CHD_XY][N_CHD_BAR];
 Float_t fNmipIMC[N_IMC_XY][N_IMC_LAYER][N_IMC_FIBER];
 Float_t fNmipTASC[N_TASC_XY][N_TASC_LAYER][N_TASC_LOG];

 Float_t fNmipSFDY[N_IMC_XY][N_MAPMT_LAYER];
 Float_t fNmipTTOP;

public:
 TYACALData();
 virtual ~TYACALData();

 void SetMIP();
 void SetTrigData(Int_t=1);

//	void Clear(){;}
 void SetNmipCHD(Int_t xy, Int_t i, Float_t E){fNmipCHD[xy][i] = E;}
 void SetNmipIMC(Int_t xy, Int_t i, Int_t j, Float_t E){fNmipIMC[xy][i][j] = E;}
 void SetNmipTASC(Int_t xy, Int_t i, Int_t j, Float_t E){fNmipTASC[xy][i][j] = E;}

 Float_t NmipCHD();
 Float_t NmipCHD(Int_t xy);
 Float_t NmipCHD(Int_t xy, Int_t i){return fNmipCHD[xy][i];}
 Float_t NmipIMC();
 Float_t NmipIMC(Int_t i);
 Float_t NmipIMC(Int_t xy, Int_t i);
 Float_t NmipIMC(Int_t xy, Int_t i, Int_t j){return fNmipIMC[xy][i][j];}
 Float_t NmipTASC();
 Float_t NmipTASC(Int_t xy, Int_t i);
 Float_t NmipTASC(Int_t xy, Int_t i, Int_t j){return fNmipTASC[xy][i][j];}

 Float_t NmipSFDY(Int_t xy, Int_t i){return fNmipSFDY[xy][i];}
 Float_t NmipTTOP(){return fNmipTTOP;}


 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TYACALData::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TYACALData::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TYACALData.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 50; }
};
# 17 "./include/MDCSimulator.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TYATrigger.hh" 1


/**************************************************
 *  *** TYATRIGGER_HH ***
 *  
 *  
 **************************************************/

# 1 "/nfs/RAID/home/kamio/local/include/TYAGlobalLibs.hh" 1


////////////////////////////////////////////////////////////
//  TYAGlobalLibs :
//   
//   My Functions
////////////////////////////////////////////////////////////

using namespace std;


namespace TYA {

//C++
int GetMini(int n, const int *a, int rn=0, ...);
int GetMini(int n, const float *a, int rn=0, ...);
int GetMini(int n, const double *a, int rn=0, ...);
int GetMaxi(int n, const int *a, int rn=0, ...);
int GetMaxi(int n, const float *a, int rn=0, ...);
int GetMaxi(int n, const double *a, int rn=0, ...);
int GetMinv(int n, const int *a, int rn=0, ...);
float GetMinv(int n, const float *a, int rn=0, ...);
double GetMinv(int n, const double *a, int rn=0, ...);
int GetMaxv(int n, const int *a, int rn=0, ...);
float GetMaxv(int n, const float *a, int rn=0, ...);
double GetMaxv(int n, const double *a, int rn=0, ...);
int Min(int, int);
float Min(float, float);
double Min(double, double);
int Max(int, int);
float Max(float, float);
double Max(double, double);
void SortDec(int, int*);
void SortDec(int, float*);
void SortDec(int, double*);
void SortInc(int, int*);
void SortInc(int, float*);
void SortInc(int, double*);
Int_t GetPOnPlate(Float_t*, Float_t*, Float_t*, Float_t*, Float_t*);
Int_t GetPOnPlate(Float_t*, Float_t*, Float_t*, int*, Float_t*);
Int_t GetPOnPlate(double*, double*, double*, double*, double*);
Int_t GetPOnPlate(double*, double*, double*, int*, double*);
Int_t GetClip(Float_t*, Float_t*, Float_t*, Float_t*);
Int_t GetClip(Float_t*, Float_t*, Float_t*, Float_t*, Float_t*);
Int_t GetClip(Float_t*, Float_t*, Float_t*, Float_t*, Float_t*, Float_t*, Float_t*);
Int_t GetClip(double*, double*, double*, double*);
Int_t GetClip(double*, double*, double*, double*, double*);
Int_t GetClip(double*, double*, double*, double*, double*, double*, double*);

void Switch(int*, int*);
void Switch(float*, float*);
void Switch(double*, double*);
int Sum(int, const int*, int=0, ...);
float Sum(int, const float*, int=0, ...);
double Sum(int, const double*, int=0, ...);

//-ROOT-
TCanvas *SetCanvas(const char*, const char* ="", int=1);
TCanvas *SetCanvas(const char*, const char*, int, int);
TCanvas *SetCanvas(const char*, const char*, int, int, int, int);
void CanvDivide(TCanvas*, int, int);
TH1C *SetHistC(const char*, const char*, int, double, double, int=0);
TH1I *SetHistI(const char*, const char*, int, double, double, int=0);
TH1F *SetHistF(const char*, const char*, int, double, double, int=0);
TH1D *SetHistD(const char*, const char*, int, double, double, int=0);

//Analysis
Double_t langaufunOrig(Double_t *x, Double_t *par);
Double_t langaufun(Double_t *x, Double_t *par);
Double_t langaufun2(Double_t *x, Double_t *par);


//Class
class TMultiHist{
public:
 TMultiHist(int, TH1F**, TCanvas* =0);
 virtual ~TMultiHist();
 void SetCanvas(TCanvas *c){fc = c;}
 Double_t GetMaximum();
 void CalcWidth();
 TH1F* DrawAll(const char *style, const char *name=0);
protected:
 int fN;
 TH1F *fh[];
 TCanvas *fc;
};


}; //namespace TYA::
//##################################################
/*
//_____________________________________________________________________________
template <typename T>
//T TYA::GetMinv(int n, const T *a, int rn, ...) {
T GetMinv(int n, const T *a, int rn, ...) {
	if(n<=0 || !a) return -1;
	va_list list;
	va_start(list, rn);
	int remove[rn];
	for(int i=0;i<rn;i++)
		remove[i] = va_arg(list, int);
	va_end(list);
	T xmin = 0;//
	int loc = -1;
	bool flag;
	bool first = kTRUE;
	for(int i=0;i<n;i++){
		flag = kTRUE;
		for(int j=0;j<rn;j++)
			if(i==remove[j]) flag = kFALSE;
		if(flag){
			if(first){
				first = kFALSE;
				xmin = a[i];
				loc = i;
			}
			else if(xmin > a[i]){
				xmin = a[i];
				loc = i;
			}
		}
	}
	return xmin;
}

//_____________________________________________________________________________
template <typename T>
T TYA::GetMaxv(int n, const T *a, int rn, ...) {
	if(n<=0 || !a) return -1;
	va_list list;
	va_start(list, rn);
	int remove[rn];
	for(int i=0;i<rn;i++)
		remove[i] = va_arg(list, int);
	va_end(list);
	T xmax = 0;//
	int loc = -1;
	bool flag;
	bool first = kTRUE;
	for(int i=0;i<n;i++){
		flag = kTRUE;
		for(int j=0;j<rn;j++)
			if(i==remove[j]) flag = kFALSE;
		if(flag){
			if(first){
				first = kFALSE;
				xmax = a[i];
				loc = i;
			}
			else if(xmax < a[i]){
				xmax = a[i];
				loc = i;
			}
		}
	}
	return xmax;
}
*/
# 10 "/nfs/RAID/home/kamio/local/include/TYATrigger.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TYACALData.hh" 1
# 11 "/nfs/RAID/home/kamio/local/include/TYATrigger.hh" 2
using namespace std;

enum EYATrigType{kTrig0=0, kTrigS, kTrigH, kTrigL};
const int BIT_YATRIG_SINGLE = (1ULL << (kTrigS));
const int BIT_YATRIG_LOW = (1ULL << (kTrigL));
const int BIT_YATRIG_HIGH = (1ULL << (kTrigH));

class TYATrigger : public TObject{
protected:
 TYACALData *fData;

public:

 static Float_t fThSFDY1_H;
 static Float_t fThSFDY2_H;
 static Float_t fThSFDY3_H;
 static Float_t fThSFDY4_H;
 static Float_t fThTTOP_H;

 static Float_t fThSFDY1_L;
 static Float_t fThSFDY2_L;
 static Float_t fThSFDY3_L;
 static Float_t fThSFDY4_L;
 static Float_t fThTTOP_L;

 static Float_t fThSFDY1_S;
 static Float_t fThSFDY2_S;
 static Float_t fThSFDY3_S;
 static Float_t fThSFDY4_S;
 static Float_t fThTTOP_S;

public:
 TYATrigger(TYACALData*);
 virtual ~TYATrigger();

 void Initialize();
 Int_t GetFlagBit();
 Int_t IsTrig(int);

protected:
 bool check_high();
 bool check_low();
 bool check_single();

 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TYATrigger::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TYATrigger::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TYATrigger.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 55; }
};
# 18 "./include/MDCSimulator.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TYAShowerAxis.hh" 1


/**************************************************
 *  *** TYASHOWERAXIS_HH ***
 *  
 *  
 **************************************************/




# 1 "/nfs/RAID/home/kamio/local/include/ZConstant.h" 1



const Double_t PI = 3.14159265358979323846;

const Double_t RL_W = 0.35054247;
const Double_t RL_PWO = 0.89251647;

const Double_t NUMLARGE = 1.e+9;
const Double_t NUMSMALL = 1.e-9;

const Double_t PWOHalfSize = 1.0;
const Double_t SFHalfSize = 0.50e-1;

const Double_t EcPWO = 9.5e-3; //critical energy
# 13 "/nfs/RAID/home/kamio/local/include/TYAShowerAxis.hh" 2
using namespace std;

class TYAShowerAxis : public TObject{
protected:

 Float_t fPos[N_XYZ];
 Float_t fDir[N_XYZ];
 Float_t fLengInTASC;
 Float_t fPinTASC[N_XYZ];
 Float_t fPotTASC[N_XYZ];

 const Int_t fFlagHit_sCHD;
 const Int_t fFlagHit_sSF;
 const Int_t fFlagHit_sW;
 const Int_t fFlagHit_sPWO;

public:
 Int_t fFlagHit;
 Int_t fFlagHitInside;

public:
 TYAShowerAxis();
 virtual ~TYAShowerAxis();
//
 void InitAll();
 Int_t IsAxisGeo(Int_t, Float_t*, Float_t*);
 void SetBit(Float_t*, Float_t*);
 void CalcLengInPWO(Float_t*, Float_t*);
//
 Float_t GetLentInTASC(){return fLengInTASC;}

 private: static TClass *fgIsA; public: static TClass *Class(); static const char *Class_Name(); static Version_t Class_Version() { return 0; } static void Dictionary(); virtual TClass *IsA() const { return TYAShowerAxis::Class(); } virtual void ShowMembers(TMemberInspector&); virtual void Streamer(TBuffer&); void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { TYAShowerAxis::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/nfs/RAID/home/kamio/local/include/TYAShowerAxis.hh"; } static int ImplFileLine(); static const char *ImplFileName(); static int DeclFileLine() { return 44; }
};
# 19 "./include/MDCSimulator.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TCALGeometry.hh" 1
# 20 "./include/MDCSimulator.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/TInteractionInfo.hh" 1
# 21 "./include/MDCSimulator.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/ZConstant.h" 1
# 22 "./include/MDCSimulator.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/ZOneMIP.h" 1
# 23 "./include/MDCSimulator.hh" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iomanip" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iomanip.h" 1
/* /% C++ %/ */
/***********************************************************************
 * cint (C/C++ interpreter)
 ************************************************************************
 * I/O manipulator header for iomanip.h
 ************************************************************************
 * Description:
 *  CINT IOMANIP header file
 ************************************************************************
 * Author                  Masaharu Goto 
 * Copyright(c) 1995~1999  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/include/iomanip" 2
}
# 24 "./include/MDCSimulator.hh" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/queue" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

namespace std {
#pragma include_noerr <queue.dll>
}



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/queue" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/queue

#pragma ifndef PREC_STL_QUEUE
#pragma define PREC_STL_QUEUE
#pragma link off global PREC_STL_QUEUE;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from ANSI/ISO C++ 1997/Nov draft 
// Got some ideas from Scott Snyder, Fermi-lab
// Modified by Masaharu Goto

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_deque" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <deque.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/deque" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/deque

#pragma ifndef PREC_STL_DEQUE
#pragma define PREC_STL_DEQUE
#pragma link off global PREC_STL_DEQUE;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from ANSI/ISO C++ 1997/Nov draft 
// Got some ideas from Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab

# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <iterator.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/iterator

#pragma ifndef PREC_STL_ITERATOR
#pragma define PREC_STL_ITERATOR
#pragma link off global PREC_STL_ITERATOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;



#pragma mask_newdelete 0x10;


// Imported from STL HP implementation 1994
// Imported from STL SGI implementation 1997 
// Imported from ANSI/ISO C++ draft Nov 1997
// Modified by Masaharu Goto
// May need improvement for the latest standard


////////////////////////////////////////////////////////////////////////
// iterator_tag
////////////////////////////////////////////////////////////////////////
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag {};
struct bidirectional_iterator_tag {};
struct random_access_iterator_tag {};

////////////////////////////////////////////////////////////////////////
// iterator template
////////////////////////////////////////////////////////////////////////
template <class T, class Distance> struct input_iterator {};
struct output_iterator {};
template <class T, class Distance> struct forward_iterator {};
template <class T, class Distance> struct bidirectional_iterator {};
template <class T, class Distance> struct random_access_iterator {};

#pragma link off class output_iterator;







////////////////////////////////////////////////////////////////////////
// iterator_category overloaded function
////////////////////////////////////////////////////////////////////////
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const input_iterator<T, Distance>&) {
    return input_iterator_tag();
}

inline output_iterator_tag iterator_category(const output_iterator&) {
    return output_iterator_tag();
}

#pragma link off function iterator_category(const output_iterator&);


template <class T, class Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<T, Distance>&) {
    return forward_iterator_tag();
}

template <class T, class Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<T, Distance>&) {
    return bidirectional_iterator_tag();
}

template <class T, class Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<T, Distance>&) {
    return random_access_iterator_tag();
}

template <class T>
inline random_access_iterator_tag
iterator_category(const T*) {
    return random_access_iterator_tag();
}


// iterator_traits, iterator and reverse_iterator template may not be
// needed for precompiled library interface 

////////////////////////////////////////////////////////////////////////
// iterator_traits
////////////////////////////////////////////////////////////////////////

template <class Iterator>
struct iterator_traits {
  typedef typename Iterator::iterator_category iterator_category;
  typedef typename Iterator::value_type value_type;
  typedef typename Iterator::difference_type difference_type;
  typedef typename Iterator::pointer pointer;
  typedef typename Iterator::reference reference;
};

// template partial specialization, implement in cint5.15.14 1587
template <class T>
struct iterator_traits<T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef T& reference;
};

// incomplete implementation in cint5.15.14 1587, need some fix
// iterator_traits<const int*> is changed as iterator_traits<const int* const>
// or something, but cint5.15.14 can not handle this well
template <class T>
struct iterator_traits<const T*> {
  typedef random_access_iterator_tag iterator_category;
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef const T* pointer;
  typedef const T& reference;
};

////////////////////////////////////////////////////////////////////////
// iterator
////////////////////////////////////////////////////////////////////////
template<class Category, class T, class Distance = ptrdiff_t,
         class Pointer = T*, class Reference = T&>
struct iterator {
  typedef T value_type;
  typedef Distance difference_type;
  typedef Pointer pointer;
  typedef Reference reference;
  typedef Category iterator_category;
};


////////////////////////////////////////////////////////////////////////
// reverse_iterator
////////////////////////////////////////////////////////////////////////






template <class Iterator>
class reverse_iterator
# 166 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
{




 public:
# 181 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
   typedef Iterator::pointer pointer;
   typedef Iterator::reference reference;
   typedef ptrdiff_t difference_type;


   reverse_iterator();
   //reverse_iterator(Iterator x);



   Iterator base() const; // explicit
   reference operator*() const;
   pointer operator->() const;
   reverse_iterator& operator++();
   reverse_iterator operator++(int);
   reverse_iterator& operator--();
   reverse_iterator operator--(int);
   reverse_iterator operator+ (difference_type n) const;
   reverse_iterator& operator+=(difference_type n);
   reverse_iterator operator- (difference_type n) const;
   reverse_iterator& operator-=(difference_type n);
   reference operator[](difference_type n) const;
};
# 932 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/iterator"
// for g++ 3.1,3.2
namespace __gnu_cxx
{
  // This iterator adapter is 'normal' in the sense that it does not
  // change the semantics of any of the operators of its iterator
  // parameter.  Its primary purpose is to convert an iterator that is
  // not a class, e.g. a pointer, into an iterator that is a class.
  // The _Container parameter exists solely so that different containers
  // using this template can instantiate different types, even if the
  // _Iterator parameter is the same.
  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
      : public iterator<typename iterator_traits<_Iterator>::iterator_category,
                        typename iterator_traits<_Iterator>::value_type,
                        typename iterator_traits<_Iterator>::difference_type,
                        typename iterator_traits<_Iterator>::pointer,
                        typename iterator_traits<_Iterator>::reference>
    {
    protected:
      _Iterator _M_current;

    public:
      typedef typename iterator_traits<_Iterator>::difference_type
                    difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

      __normal_iterator() : _M_current(_Iterator()) { }

      explicit
      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

      // Allow iterator to const_iterator conversion
      template<typename _Iter>
      inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
 : _M_current(__i.base()) { }

      // Forward iterator requirements
      reference
      operator*() const { return *_M_current; }

      pointer
      operator->() const { return _M_current; }

      __normal_iterator&
      operator++() { ++_M_current; return *this; }

      __normal_iterator
      operator++(int) { return __normal_iterator(_M_current++); }

      // Bidirectional iterator requirements
      __normal_iterator&
      operator--() { --_M_current; return *this; }

      __normal_iterator
      operator--(int) { return __normal_iterator(_M_current--); }

      // Random access iterator requirements
      reference
      operator[](const difference_type& __n) const
      { return _M_current[__n]; }

      __normal_iterator&
      operator+=(const difference_type& __n)
      { _M_current += __n; return *this; }

      __normal_iterator
      operator+(const difference_type& __n) const
      { return __normal_iterator(_M_current + __n); }

      __normal_iterator&
      operator-=(const difference_type& __n)
      { _M_current -= __n; return *this; }

      __normal_iterator
      operator-(const difference_type& __n) const
      { return __normal_iterator(_M_current - __n); }

      const _Iterator&
      base() const { return _M_current; }
    };

  // Note: In what follows, the left- and right-hand-side iterators are
  // allowed to vary in types (conceptually in cv-qualification) so that
  // comparaison between cv-qualified and non-cv-qualified iterators be
  // valid.  However, the greedy and unfriendly operators in std::rel_ops
  // will make overload resolution ambiguous (when in scope) if we don't
  // provide overloads whose operands are of the same type.  Can someone
  // remind me what generic programming is about? -- Gaby

  // Forward iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

  // Random access iterator requirements
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
             const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

  // _GLIBCPP_RESOLVE_LIB_DEFECTS
  // According to the resolution of DR179 not only the various comparison
  // operators but also operator- must accept mixed iterator/const_iterator
  // parameters.
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
     const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
} // namespace __gnu_cxx







#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_iterator" 2
# 27 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/deque" 2
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_memory" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/

#pragma include_noerr <memory.dll>



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// lib/prec_stl/memory

#pragma ifndef PREC_STL_MEMORY
#pragma define PREC_STL_MEMORY
#pragma link off global PREC_STL_MEMORY;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;

// Implemented by Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab
# 27 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
//////////////////////////////////////////////////////////////////////


template <class _Tp>
class allocator {
  //typedef alloc _Alloc;          // The underlying allocator.
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef typename _Tp* pointer;
  typedef const typename _Tp * const_pointer;




  typedef _Tp& reference;
  typedef const _Tp& const_reference;
  typedef _Tp value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };

  allocator() ;
  allocator(const allocator&) ;
  //template <class _Tp1> allocator(const allocator<_Tp1>&) ;
  ~allocator() ;

  pointer address(reference __x) const ;
  const_pointer address(const_reference __x) const ;

  // __n is permitted to be 0.  The C++ standard says nothing about what
  // the return value is when __n == 0.
  _Tp* allocate(size_type __n, const void* = 0) ;

  // __p is not permitted to be a null pointer.
  void deallocate(pointer __p, size_type __n);

  size_type max_size() const ;

  void construct(pointer __p, const _Tp& __val) ;
  void destroy(pointer __p) ;
};

template<>
class allocator<void> {
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef void* pointer;
  typedef const void* const_pointer;
  typedef void value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };
};
//////////////////////////////////////////////////////////////////////
# 205 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
//////////////////////////////////////////////////////////////////////

/**********************************************************************
* auto_ptr
**********************************************************************/
template <class X> class auto_ptr {
private:
  X* ptr;
  //template<class Y> struct auto_ptr_ref { };
public:
  typedef X element_type;
  explicit auto_ptr(X* p = 0) : ptr(p) {}
  auto_ptr(auto_ptr& a) {ptr=a.ptr;}

  // this implementation may not be correct
  template <class T> auto_ptr(auto_ptr<T>& a) {ptr=a.release();}
# 229 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
  auto_ptr& operator=(auto_ptr& a) {
    if (a.ptr != ptr) {
      delete ptr;
      ptr = a.ptr;
    }
    return(*this);
  }

  // this implementation may not be correct
  template <class T> auto_ptr& operator=(auto_ptr<T>& a) {
    if (a.ptr != ptr) {
       delete ptr;
       ptr = a.release();
    }
    return(*this);
  }

  ~auto_ptr() { delete ptr; }

  X& operator*() const { return *ptr; }
  X* operator->() const { return ptr; }
  X* get() const { return ptr; }
  X* release() { X *old = ptr; ptr = 0; return 0; }
# 262 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/memory"
  // auto_ptr conversions
  //auto_ptr(auto_ptr_ref<X>& x) { }
  //template<class Y> operator auto_ptr_ref<Y>() { return auto_ptr_ref<Y>(); }
  //template<class Y> operator auto_ptr<Y>() { return auto_ptr<T>(); }
};

#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_memory" 2
# 28 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/deque" 2


template<class T,class Allocator=std::allocator<T> >
# 42 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/deque"
class deque {
 public:
  typedef T value_type;
  typedef Allocator allocator_type;

  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
# 62 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/deque"
  class iterator
# 77 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/deque"
 {
   public:
    iterator() ;
    iterator(const iterator& x) ;


    iterator& operator=(const iterator& x) ;

    T& operator*() const ;

    T* operator->() const;

    iterator& operator++();
    iterator operator++(int a);
    iterator& operator--();
    iterator operator--(int a);
# 102 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/deque"
    iterator operator+(long n);
    iterator operator-(long n);
    iterator& operator+=(long n);
    iterator& operator-=(long n);
    T& operator[](long n) ;
  };




  friend bool operator==(const deque::iterator& x
                        ,const deque::iterator& y) const;
  friend bool operator!=(const deque::iterator& x
                        ,const deque::iterator& y) const;


  class reverse_iterator
# 133 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/deque"
 {
   public:
    reverse_iterator(const reverse_iterator& x);

    reverse_iterator& operator=(const reverse_iterator& x) ;




    T& operator*() const ;


    T* operator->() const;

    reverse_iterator& operator++();
    reverse_iterator operator++(int a);
    reverse_iterator& operator--();
    reverse_iterator operator--(int a);
    reverse_iterator operator+(long n);
    reverse_iterator operator-(long n);
    reverse_iterator& operator+=(long n);
    reverse_iterator& operator-=(long n);
    T& operator[](long n) ;
   private:
  };
  friend bool operator==(const deque::reverse_iterator& x
                        ,const deque::reverse_iterator& y) const;
  friend bool operator!=(const deque::reverse_iterator& x
                        ,const deque::reverse_iterator& y) const;

  typedef const iterator const_iterator;
  typedef const reverse_iterator const_reverse_iterator;

  deque();
  deque(size_type n, const T& value = T());






  deque(const T* first,const T* last) ;

  deque(const_iterator first, const_iterator last);

  deque(const deque& x);
  ~deque();
  deque& operator=(const deque& x);







  //allocator_type get_allocator() const;
  // iterators:
  iterator begin();
  iterator end();
  reverse_iterator rbegin();
  reverse_iterator rend();






  // _lib.deque.capacity_ capacity:
  size_type size() const;
  size_type max_size() const;
  void resize(size_type sz, T c = T());
  bool empty() const;

  // element access:
  T& operator[](size_type n);
  //const_reference operator[](size_type n) const;



  //const_reference at(size_type n) const;
  T& front();
  //const_reference front() const;
  T& back();
  //const_reference back() const;
  // _lib.deque.modifiers_ modifiers:
  void push_front(const T& x);
  void push_back(const T& x);
  iterator insert(iterator position, const T& x);
  void insert(iterator position, size_type n, const T& x);





  void pop_front();
  void pop_back();
  iterator erase(iterator position);
  iterator erase(iterator first, iterator last);
  void swap(deque<T,Allocator>&);
  void clear();

  friend bool operator==(const deque& x, const deque& y);
  friend bool operator< (const deque& x, const deque& y);
  friend bool operator!=(const deque& x, const deque& y);
  friend bool operator> (const deque& x, const deque& y);
  friend bool operator>=(const deque& x, const deque& y);
  friend bool operator<=(const deque& x, const deque& y);
  // specialized algorithms:





#pragma ifndef G__NOALGORITHM
  // Generic algorithm


  // input iter
  friend deque::iterator
    find(deque::iterator first,deque::iterator last,const T& value);
  // forward iter
  friend deque::iterator
    find_end(deque::iterator first1,deque::iterator last1,
      deque::iterator first2,deque::iterator last2);
  friend deque::iterator
    find_first_of(deque::iterator first1,deque::iterator last1,
           deque::iterator first2,deque::iterator last2);
  friend deque::iterator
    adjacent_find(deque::iterator first,deque::iterator last);
  // input iter

  friend deque::difference_type
    count(deque::iterator first,deque::iterator last,const T& value);






  friend bool
    equal(deque::iterator first1,deque::iterator last1,
          deque::iterator first2);
  // forward iter
  friend deque::iterator
    search(deque::iterator first1,deque::iterator last1,
           deque::iterator first2,deque::iterator last2);
  friend deque::iterator
    search_n(deque::iterator first,deque::iterator last
             ,deque::size_type count,const T& value);
  // input and output iter -> forward iter
  friend deque::iterator
    copy(deque::iterator first,deque::iterator last,
         deque::iterator result);
  // bidirectional iter
  friend deque::iterator
    copy_backward(deque::iterator first,deque::iterator last,
                  deque::iterator result);
  // just value_type
  friend void swap(T& a,T& b);
  // forward iter
  friend deque::iterator
    swap_ranges(deque::iterator first1,deque::iterator last1,
                deque::iterator first2);
  friend void iter_swap(deque::iterator a,deque::iterator b);
  friend void replace(deque::iterator first,deque::iterator last,
                      const T& old_value,const T& new_value);
  // input, output iter -> forward iter
  friend deque::iterator
    replace_copy(deque::iterator first,deque::iterator last,
                 deque::iterator result,
                 const T& old_value,const T& new_value);
  // forward iter
  friend void
    fill(deque::iterator first,deque::iterator last,const T& value);

  friend void
    fill_n(deque::iterator first,deque::size_type n,const T& value);

  friend deque::iterator
    remove(deque::iterator first,deque::iterator last,const T& value);
  // input,output iter -> forward iter
  friend deque::iterator
    remove_copy(deque::iterator first,deque::iterator last,
                deque::iterator result,const T& value);
  friend deque::iterator
    unique(deque::iterator first,deque::iterator last);
  friend deque::iterator
    unique_copy(deque::iterator first,deque::iterator last,
                deque::iterator result);
  friend void reverse(deque::iterator first,deque::iterator last);
  friend deque::iterator
     reverse_copy(deque::iterator first,deque::iterator last,
                  deque::iterator result);
  // forward iter
  friend void rotate(deque::iterator first,deque::iterator mid,
                     deque::iterator last);
  // forward iter
  friend deque::iterator
    rotate_copy(deque::iterator first,deque::iterator mid,
                deque::iterator last,deque::iterator result);
  // randomaccess iter
  friend void random_shuffle(deque::iterator first,deque::iterator last);
  // randomaccess iter
  friend void sort(deque::iterator first,deque::iterator last);
  friend void stable_sort(deque::iterator first,deque::iterator last);
  friend void partial_sort(deque::iterator first,deque::iterator mid,
                           deque::iterator last);
  friend deque::iterator
    partial_sort_copy(deque::iterator first,deque::iterator last,
                      deque::iterator result_first,
                      deque::iterator result_last);
  friend void nth_element(deque::iterator first,deque::iterator nth,
                          deque::iterator last);
  // forward iter
  friend deque::iterator
    lower_bound(deque::iterator first,deque::iterator last,const T& value);
  friend deque::iterator
    upper_bound(deque::iterator first,deque::iterator last,const T& value);




  friend bool binary_search(deque::iterator first,deque::iterator last,
                            const T& value);
  friend deque::iterator merge(deque::iterator first1,deque::iterator last1,
                                deque::iterator first2,deque::iterator last2,
                                deque::iterator result);
  friend void inplace_merge(deque::iterator first,deque::iterator middle,
                            deque::iterator last);
  friend bool includes(deque::iterator first1,deque::iterator last1,
                       deque::iterator first2,deque::iterator last2);
  friend deque::iterator
    set_union(deque::iterator first1,deque::iterator last1,
              deque::iterator first2,deque::iterator last2,
              deque::iterator result);
  friend deque::iterator
    set_intersection(deque::iterator first1,deque::iterator last1,
                     deque::iterator first2,deque::iterator last2,
                     deque::iterator result);
  friend deque::iterator
    set_difference(deque::iterator first1,deque::iterator last1,
                   deque::iterator first2,deque::iterator last2,
                   deque::iterator result);
  friend deque::iterator
    set_symmetric_difference(deque::iterator first1,deque::iterator last1,
                             deque::iterator first2,deque::iterator last2,
                             deque::iterator result);
  // random access
  friend void push_heap(deque::iterator first,deque::iterator last);
  friend void pop_heap(deque::iterator first,deque::iterator last);
  friend void make_heap(deque::iterator first,deque::iterator last);
  friend void sort_heap(deque::iterator first,deque::iterator last);
  // min,max, just value_type
  friend const T& min(const T& a,const T& b);
  friend const T& max(const T& a,const T& b);
  // forward iter
  friend deque::iterator
    min_element(deque::iterator first,deque::iterator last);
  friend deque::iterator
    max_element(deque::iterator first,deque::iterator last);
  // input iter
  friend bool
    lexicographical_compare(deque::iterator first1,deque::iterator last1,
                            deque::iterator first2,deque::iterator last2);
  // bidirectional iter
  friend bool next_permutation(deque::iterator first,deque::iterator last);
  friend bool prev_permutation(deque::iterator first,deque::iterator last);
# 425 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/deque"
#pragma endif

  // Generic algorithm
  //friend void reverse(deque::iterator first,deque::iterator last);
  //friend void reverse(deque::reverse_iterator first,deque::reverse_itetator last);

  // iterator_category resolution
  //friend random_access_iterator_tag iterator_category(deque::iterator x);
};

#pragma endif
# 14 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_deque" 2
# 26 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/lib/prec_stl/queue" 2

template <class T, class Container = deque<T> >
class queue {
 public:
  typedef typename Container::value_type value_type;
  typedef typename Container::size_type size_type;
  typedef Container container_type;
 protected:
  Container c;
 public:

  queue();
  //queue(const Container&);



  queue();

  bool empty() const;
  size_type size() const;
  value_type& front();
  //const value_type& front() const;
  value_type& back();
  //const value_type& back() const;

  void push(const T& x);



  void pop();


  friend bool operator==(const queue& x, const queue& y);
  friend bool operator< (const queue& x, const queue& y);
  friend bool operator!=(const queue& x, const queue& y);
  friend bool operator> (const queue& x, const queue& y);
  friend bool operator>=(const queue& x, const queue& y);
  friend bool operator<=(const queue& x, const queue& y);

};

#pragma endif
# 16 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/queue" 2
# 25 "./include/MDCSimulator.hh" 2

/* 130622 YA added *************************** from here */

# 1 "/usr/include/libpq-fe.h" 1 3 4
/*-------------------------------------------------------------------------
 *
 * libpq-fe.h
 *	  This file contains definitions for structures and
 *	  externs for functions used by frontend postgres applications.
 *
 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * $PostgreSQL: pgsql/src/interfaces/libpq/libpq-fe.h,v 1.147 2009/06/11 14:49:14 momjian Exp $
 *
 *-------------------------------------------------------------------------
 */





extern "C"
{




/*
 * postgres_ext.h defines the backend's externally visible types,
 * such as Oid.
 */
# 1 "/usr/include/postgres_ext.h" 1 3 4
/*-------------------------------------------------------------------------
 *
 * postgres_ext.h
 *
 *	   This file contains declarations of things that are visible everywhere
 *	in PostgreSQL *and* are visible to clients of frontend interface libraries.
 *	For example, the Oid type is part of the API of libpq and other libraries.
 *
 *	   Declarations which are specific to a particular interface should
 *	go in the header file for that interface (such as libpq-fe.h).	This
 *	file is only for fundamental Postgres declarations.
 *
 *	   User-written C functions don't count as "external to Postgres."
 *	Those function much as local modifications to the backend itself, and
 *	use header files that are otherwise internal to Postgres to interface
 *	with the backend.
 *
 * $PostgreSQL: pgsql/src/include/postgres_ext.h,v 1.17 2007/02/06 09:16:08 petere Exp $
 *
 *-------------------------------------------------------------------------
 */




/*
 * Object ID is a fundamental type in Postgres.
 */
typedef unsigned int Oid;
# 38 "/usr/include/postgres_ext.h" 3 4
/* you will need to include <limits.h> to use the above #define */


/*
 * Identifiers of error message fields.  Kept here to keep common
 * between frontend and backend, and also to export them to libpq
 * applications.
 */
# 30 "/usr/include/libpq-fe.h" 2 3 4

/*
 * Option flags for PQcopyResult
 */





/* Application-visible enum types */

typedef enum
{
 /*
	 * Although it is okay to add to this list, values which become unused
	 * should never be removed, nor should constants be redefined - that would
	 * break compatibility with existing code.
	 */
 CONNECTION_OK,
 CONNECTION_BAD,
 /* Non-blocking mode only below here */

 /*
	 * The existence of these should never be relied upon - they should only
	 * be used for user feedback or similar purposes.
	 */
 CONNECTION_STARTED, /* Waiting for connection to be made.  */
 CONNECTION_MADE, /* Connection OK; waiting to send.	   */
 CONNECTION_AWAITING_RESPONSE, /* Waiting for a response from the
										 * postmaster.		  */
 CONNECTION_AUTH_OK, /* Received authentication; waiting for
								 * backend startup. */
 CONNECTION_SETENV, /* Negotiating environment. */
 CONNECTION_SSL_STARTUP, /* Negotiating SSL. */
 CONNECTION_NEEDED /* Internal state: connect() needed */
} ConnStatusType;

typedef enum
{
 PGRES_POLLING_FAILED = 0,
 PGRES_POLLING_READING, /* These two indicate that one may	  */
 PGRES_POLLING_WRITING, /* use select before polling again.   */
 PGRES_POLLING_OK,
 PGRES_POLLING_ACTIVE /* unused; keep for awhile for backwards
								 * compatibility */
} PostgresPollingStatusType;

typedef enum
{
 PGRES_EMPTY_QUERY = 0, /* empty query string was executed */
 PGRES_COMMAND_OK, /* a query command that doesn't return
								 * anything was executed properly by the
								 * backend */
 PGRES_TUPLES_OK, /* a query command that returns tuples was
								 * executed properly by the backend, PGresult
								 * contains the result tuples */
 PGRES_COPY_OUT, /* Copy Out data transfer in progress */
 PGRES_COPY_IN, /* Copy In data transfer in progress */
 PGRES_BAD_RESPONSE, /* an unexpected response was recv'd from the
								 * backend */
 PGRES_NONFATAL_ERROR, /* notice or warning message */
 PGRES_FATAL_ERROR /* query failed */
} ExecStatusType;

typedef enum
{
 PQTRANS_IDLE, /* connection idle */
 PQTRANS_ACTIVE, /* command in progress */
 PQTRANS_INTRANS, /* idle, within transaction block */
 PQTRANS_INERROR, /* idle, within failed transaction */
 PQTRANS_UNKNOWN /* cannot determine status */
} PGTransactionStatusType;

typedef enum
{
 PQERRORS_TERSE, /* single-line error messages */
 PQERRORS_DEFAULT, /* recommended style */
 PQERRORS_VERBOSE /* all the facts, ma'am */
} PGVerbosity;

/* PGconn encapsulates a connection to the backend.
 * The contents of this struct are not supposed to be known to applications.
 */
typedef struct pg_conn PGconn;

/* PGresult encapsulates the result of a query (or more precisely, of a single
 * SQL command --- a query string given to PQsendQuery can contain multiple
 * commands and thus return multiple PGresult objects).
 * The contents of this struct are not supposed to be known to applications.
 */
typedef struct pg_result PGresult;

/* PGcancel encapsulates the information needed to cancel a running
 * query on an existing connection.
 * The contents of this struct are not supposed to be known to applications.
 */
typedef struct pg_cancel PGcancel;

/* PGnotify represents the occurrence of a NOTIFY message.
 * Ideally this would be an opaque typedef, but it's so simple that it's
 * unlikely to change.
 * NOTE: in Postgres 6.4 and later, the be_pid is the notifying backend's,
 * whereas in earlier versions it was always your own backend's PID.
 */
typedef struct pgNotify
{
 char *relname; /* notification condition name */
 int be_pid; /* process ID of notifying server process */
 char *extra; /* notification parameter */
 /* Fields below here are private to libpq; apps should not use 'em */
 struct pgNotify *next; /* list link */
} PGnotify;

/* Function types for notice-handling callbacks */
typedef void (*PQnoticeReceiver) (void *arg, const PGresult *res);
typedef void (*PQnoticeProcessor) (void *arg, const char *message);

/* Print options for PQprint() */
typedef char pqbool;

typedef struct _PQprintOpt
{
 pqbool header; /* print output field headings and row count */
 pqbool align; /* fill align the fields */
 pqbool standard; /* old brain dead format */
 pqbool html3; /* output html tables */
 pqbool expanded; /* expand tables */
 pqbool pager; /* use pager for output if needed */
 char *fieldSep; /* field separator */
 char *tableOpt; /* insert to HTML <table ...> */
 char *caption; /* HTML <caption> */
 char **fieldName; /* null terminated array of replacement field
								 * names */
} PQprintOpt;

/* ----------------
 * Structure for the conninfo parameter definitions returned by PQconndefaults
 * or PQconninfoParse.
 *
 * All fields except "val" point at static strings which must not be altered.
 * "val" is either NULL or a malloc'd current-value string.  PQconninfoFree()
 * will release both the val strings and the PQconninfoOption array itself.
 * ----------------
 */
typedef struct _PQconninfoOption
{
 char *keyword; /* The keyword of the option			*/
 char *envvar; /* Fallback environment variable name	*/
 char *compiled; /* Fallback compiled in default value	*/
 char *val; /* Option's current value, or NULL		 */
 char *label; /* Label for field in connect dialog	*/
 char *dispchar; /* Indicates how to display this field in a
								 * connect dialog. Values are: "" Display
								 * entered value as is "*" Password field -
								 * hide value "D"  Debug option - don't show
								 * by default */
 int dispsize; /* Field size in characters for dialog	*/
} PQconninfoOption;

/* ----------------
 * PQArgBlock -- structure for PQfn() arguments
 * ----------------
 */
typedef struct
{
 int len;
 int isint;
 union
 {
  int *ptr; /* can't use void (dec compiler barfs)	 */
  int integer;
 } u;
} PQArgBlock;

/* ----------------
 * PGresAttDesc -- Data about a single attribute (column) of a query result
 * ----------------
 */
typedef struct pgresAttDesc
{
 char *name; /* column name */
 Oid tableid; /* source table, if known */
 int columnid; /* source column, if known */
 int format; /* format code for value (text/binary) */
 Oid typid; /* type id */
 int typlen; /* type size */
 int atttypmod; /* type-specific modifier info */
} PGresAttDesc;

/* ----------------
 * Exported functions of libpq
 * ----------------
 */

/* ===	in fe-connect.c === */

/* make a new client connection to the backend */
/* Asynchronous (non-blocking) */
extern PGconn *PQconnectStart(const char *conninfo);
extern PostgresPollingStatusType PQconnectPoll(PGconn *conn);

/* Synchronous (blocking) */
extern PGconn *PQconnectdb(const char *conninfo);
extern PGconn *PQsetdbLogin(const char *pghost, const char *pgport,
    const char *pgoptions, const char *pgtty,
    const char *dbName,
    const char *login, const char *pwd);




/* close the current connection and free the PGconn data structure */
extern void PQfinish(PGconn *conn);

/* get info about connection options known to PQconnectdb */
extern PQconninfoOption *PQconndefaults(void);

/* parse connection options in same way as PQconnectdb */
extern PQconninfoOption *PQconninfoParse(const char *conninfo, char **errmsg);

/* free the data structure returned by PQconndefaults() or PQconninfoParse() */
extern void PQconninfoFree(PQconninfoOption *connOptions);

/*
 * close the current connection and restablish a new one with the same
 * parameters
 */
/* Asynchronous (non-blocking) */
extern int PQresetStart(PGconn *conn);
extern PostgresPollingStatusType PQresetPoll(PGconn *conn);

/* Synchronous (blocking) */
extern void PQreset(PGconn *conn);

/* request a cancel structure */
extern PGcancel *PQgetCancel(PGconn *conn);

/* free a cancel structure */
extern void PQfreeCancel(PGcancel *cancel);

/* issue a cancel request */
extern int PQcancel(PGcancel *cancel, char *errbuf, int errbufsize);

/* backwards compatible version of PQcancel; not thread-safe */
extern int PQrequestCancel(PGconn *conn);

/* Accessor functions for PGconn objects */
extern char *PQdb(const PGconn *conn);
extern char *PQuser(const PGconn *conn);
extern char *PQpass(const PGconn *conn);
extern char *PQhost(const PGconn *conn);
extern char *PQport(const PGconn *conn);
extern char *PQtty(const PGconn *conn);
extern char *PQoptions(const PGconn *conn);
extern ConnStatusType PQstatus(const PGconn *conn);
extern PGTransactionStatusType PQtransactionStatus(const PGconn *conn);
extern const char *PQparameterStatus(const PGconn *conn,
      const char *paramName);
extern int PQprotocolVersion(const PGconn *conn);
extern int PQserverVersion(const PGconn *conn);
extern char *PQerrorMessage(const PGconn *conn);
extern int PQsocket(const PGconn *conn);
extern int PQbackendPID(const PGconn *conn);
extern int PQconnectionNeedsPassword(const PGconn *conn);
extern int PQconnectionUsedPassword(const PGconn *conn);
extern int PQclientEncoding(const PGconn *conn);
extern int PQsetClientEncoding(PGconn *conn, const char *encoding);

/* Get the OpenSSL structure associated with a connection. Returns NULL for
 * unencrypted connections or if any other TLS library is in use. */
extern void *PQgetssl(PGconn *conn);

/* Tell libpq whether it needs to initialize OpenSSL */
extern void PQinitSSL(int do_init);

/* More detailed way to tell libpq whether it needs to initialize OpenSSL */
extern void PQinitOpenSSL(int do_ssl, int do_crypto);

/* Set verbosity for PQerrorMessage and PQresultErrorMessage */
extern PGVerbosity PQsetErrorVerbosity(PGconn *conn, PGVerbosity verbosity);

/* Enable/disable tracing */
extern void PQtrace(PGconn *conn, FILE *debug_port);
extern void PQuntrace(PGconn *conn);

/* Override default notice handling routines */
extern PQnoticeReceiver PQsetNoticeReceiver(PGconn *conn,
     PQnoticeReceiver proc,
     void *arg);
extern PQnoticeProcessor PQsetNoticeProcessor(PGconn *conn,
      PQnoticeProcessor proc,
      void *arg);

/*
 *	   Used to set callback that prevents concurrent access to
 *	   non-thread safe functions that libpq needs.
 *	   The default implementation uses a libpq internal mutex.
 *	   Only required for multithreaded apps that use kerberos
 *	   both within their app and for postgresql connections.
 */
typedef void (*pgthreadlock_t) (int acquire);

extern pgthreadlock_t PQregisterThreadLock(pgthreadlock_t newhandler);

/* === in fe-exec.c === */

/* Simple synchronous query */
extern PGresult *PQexec(PGconn *conn, const char *query);
extern PGresult *PQexecParams(PGconn *conn,
    const char *command,
    int nParams,
    const Oid *paramTypes,
    const char *const * paramValues,
    const int *paramLengths,
    const int *paramFormats,
    int resultFormat);
extern PGresult *PQprepare(PGconn *conn, const char *stmtName,
    const char *query, int nParams,
    const Oid *paramTypes);
extern PGresult *PQexecPrepared(PGconn *conn,
      const char *stmtName,
      int nParams,
      const char *const * paramValues,
      const int *paramLengths,
      const int *paramFormats,
      int resultFormat);

/* Interface for multiple-result or asynchronous queries */
extern int PQsendQuery(PGconn *conn, const char *query);
extern int PQsendQueryParams(PGconn *conn,
      const char *command,
      int nParams,
      const Oid *paramTypes,
      const char *const * paramValues,
      const int *paramLengths,
      const int *paramFormats,
      int resultFormat);
extern int PQsendPrepare(PGconn *conn, const char *stmtName,
     const char *query, int nParams,
     const Oid *paramTypes);
extern int PQsendQueryPrepared(PGconn *conn,
     const char *stmtName,
     int nParams,
     const char *const * paramValues,
     const int *paramLengths,
     const int *paramFormats,
     int resultFormat);
extern PGresult *PQgetResult(PGconn *conn);

/* Routines for managing an asynchronous query */
extern int PQisBusy(PGconn *conn);
extern int PQconsumeInput(PGconn *conn);

/* LISTEN/NOTIFY support */
extern PGnotify *PQnotifies(PGconn *conn);

/* Routines for copy in/out */
extern int PQputCopyData(PGconn *conn, const char *buffer, int nbytes);
extern int PQputCopyEnd(PGconn *conn, const char *errormsg);
extern int PQgetCopyData(PGconn *conn, char **buffer, int async);

/* Deprecated routines for copy in/out */
extern int PQgetline(PGconn *conn, char *string, int length);
extern int PQputline(PGconn *conn, const char *string);
extern int PQgetlineAsync(PGconn *conn, char *buffer, int bufsize);
extern int PQputnbytes(PGconn *conn, const char *buffer, int nbytes);
extern int PQendcopy(PGconn *conn);

/* Set blocking/nonblocking connection to the backend */
extern int PQsetnonblocking(PGconn *conn, int arg);
extern int PQisnonblocking(const PGconn *conn);
extern int PQisthreadsafe(void);

/* Force the write buffer to be written (or at least try) */
extern int PQflush(PGconn *conn);

/*
 * "Fast path" interface --- not really recommended for application
 * use
 */
extern PGresult *PQfn(PGconn *conn,
  int fnid,
  int *result_buf,
  int *result_len,
  int result_is_int,
  const PQArgBlock *args,
  int nargs);

/* Accessor functions for PGresult objects */
extern ExecStatusType PQresultStatus(const PGresult *res);
extern char *PQresStatus(ExecStatusType status);
extern char *PQresultErrorMessage(const PGresult *res);
extern char *PQresultErrorField(const PGresult *res, int fieldcode);
extern int PQntuples(const PGresult *res);
extern int PQnfields(const PGresult *res);
extern int PQbinaryTuples(const PGresult *res);
extern char *PQfname(const PGresult *res, int field_num);
extern int PQfnumber(const PGresult *res, const char *field_name);
extern Oid PQftable(const PGresult *res, int field_num);
extern int PQftablecol(const PGresult *res, int field_num);
extern int PQfformat(const PGresult *res, int field_num);
extern Oid PQftype(const PGresult *res, int field_num);
extern int PQfsize(const PGresult *res, int field_num);
extern int PQfmod(const PGresult *res, int field_num);
extern char *PQcmdStatus(PGresult *res);
extern char *PQoidStatus(const PGresult *res); /* old and ugly */
extern Oid PQoidValue(const PGresult *res); /* new and improved */
extern char *PQcmdTuples(PGresult *res);
extern char *PQgetvalue(const PGresult *res, int tup_num, int field_num);
extern int PQgetlength(const PGresult *res, int tup_num, int field_num);
extern int PQgetisnull(const PGresult *res, int tup_num, int field_num);
extern int PQnparams(const PGresult *res);
extern Oid PQparamtype(const PGresult *res, int param_num);

/* Describe prepared statements and portals */
extern PGresult *PQdescribePrepared(PGconn *conn, const char *stmt);
extern PGresult *PQdescribePortal(PGconn *conn, const char *portal);
extern int PQsendDescribePrepared(PGconn *conn, const char *stmt);
extern int PQsendDescribePortal(PGconn *conn, const char *portal);

/* Delete a PGresult */
extern void PQclear(PGresult *res);

/* For freeing other alloc'd results, such as PGnotify structs */
extern void PQfreemem(void *ptr);

/* Exists for backward compatibility.  bjm 2003-03-24 */


/* Error when no password was given. */
/* Note: depending on this is deprecated; use PQconnectionNeedsPassword(). */


/* Create and manipulate PGresults */
extern PGresult *PQmakeEmptyPGresult(PGconn *conn, ExecStatusType status);
extern PGresult *PQcopyResult(const PGresult *src, int flags);
extern int PQsetResultAttrs(PGresult *res, int numAttributes, PGresAttDesc *attDescs);
extern void *PQresultAlloc(PGresult *res, size_t nBytes);
extern int PQsetvalue(PGresult *res, int tup_num, int field_num, char *value, int len);

/* Quoting strings before inclusion in queries. */
extern size_t PQescapeStringConn(PGconn *conn,
       char *to, const char *from, size_t length,
       int *error);
extern unsigned char *PQescapeByteaConn(PGconn *conn,
      const unsigned char *from, size_t from_length,
      size_t *to_length);
extern unsigned char *PQunescapeBytea(const unsigned char *strtext,
    size_t *retbuflen);

/* These forms are deprecated! */
extern size_t PQescapeString(char *to, const char *from, size_t length);
extern unsigned char *PQescapeBytea(const unsigned char *from, size_t from_length,
     size_t *to_length);



/* === in fe-print.c === */

extern void
PQprint(FILE *fout, /* output stream */
  const PGresult *res,
  const PQprintOpt *ps); /* option structure */

/*
 * really old printing routines
 */
extern void
PQdisplayTuples(const PGresult *res,
    FILE *fp, /* where to send the output */
    int fillAlign, /* pad the fields with spaces */
    const char *fieldSep, /* field separator */
    int printHeader, /* display headers? */
    int quiet);

extern void
PQprintTuples(const PGresult *res,
     FILE *fout, /* output stream */
     int printAttName, /* print attribute names */
     int terseOutput, /* delimiter bars */
     int width); /* width of column, if 0, use variable width */


/* === in fe-lobj.c === */

/* Large-object access routines */
extern int lo_open(PGconn *conn, Oid lobjId, int mode);
extern int lo_close(PGconn *conn, int fd);
extern int lo_read(PGconn *conn, int fd, char *buf, size_t len);
extern int lo_write(PGconn *conn, int fd, const char *buf, size_t len);
extern int lo_lseek(PGconn *conn, int fd, int offset, int whence);
extern Oid lo_creat(PGconn *conn, int mode);
extern Oid lo_create(PGconn *conn, Oid lobjId);
extern int lo_tell(PGconn *conn, int fd);
extern int lo_truncate(PGconn *conn, int fd, size_t len);
extern int lo_unlink(PGconn *conn, Oid lobjId);
extern Oid lo_import(PGconn *conn, const char *filename);
extern Oid lo_import_with_oid(PGconn *conn, const char *filename, Oid lobjId);
extern int lo_export(PGconn *conn, Oid lobjId, const char *filename);

/* === in fe-misc.c === */

/* Determine length of multibyte encoded char at *s */
extern int PQmblen(const char *s, int encoding);

/* Determine display length of multibyte encoded char at *s */
extern int PQdsplen(const char *s, int encoding);

/* Get encoding id from environment variable PGCLIENTENCODING */
extern int PQenv2encoding(void);

/* === in fe-auth.c === */

extern char *PQencryptPassword(const char *passwd, const char *user);

/* === in encnames.c === */

extern int pg_char_to_encoding(const char *name);
extern const char *pg_encoding_to_char(int encoding);
extern int pg_valid_server_encoding_id(int encoding);


}
# 29 "./include/MDCSimulator.hh" 2
# 1 "/nfs/RAID/home/kamio/local/include/dbint.h" 1



# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/string" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
namespace std {
# 1 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/_string" 1
/* -*- C++ -*- */
/*************************************************************************
 * Copyright(c) 1995~2005  Masaharu Goto (root-cint@cern.ch)
 *
 * For the licensing terms see the file COPYING
 *
 ************************************************************************/
// string
# 10 "/misc/RAID/opt/root/v5.34.01_sl61/cint/cint/stl/string" 2
}
# 5 "/nfs/RAID/home/kamio/local/include/dbint.h" 2

# 1 "/usr/include/libpq-fe.h" 1 3 4
/*-------------------------------------------------------------------------
 *
 * libpq-fe.h
 *	  This file contains definitions for structures and
 *	  externs for functions used by frontend postgres applications.
 *
 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * $PostgreSQL: pgsql/src/interfaces/libpq/libpq-fe.h,v 1.147 2009/06/11 14:49:14 momjian Exp $
 *
 *-------------------------------------------------------------------------
 */
# 7 "/nfs/RAID/home/kamio/local/include/dbint.h" 2

class CALETDBINT
{
public:
CALETDBINT();
~CALETDBINT();
void settimezone(std::string timezone);
void setcalibversion(int vid);
void setdetectorversion(int iid);
void setcalibversion(std::string cv);
void setdetectorversion(std::string dv);
PGresult *select(std::string column, std::string table, std::string condition);
int getbestcalibversion(int iid, std::string timestamp);
void setbestcalibversion(int iid, std::string timestamp);
int getdeviceidbyreadout(std::string region, std::string readout, int axis, int layer, int VA, int channel);
int getdeviceidbyvolname(std::string volname);
int getidofreadoutdevice(std::string readout, int mid);
double getreadoutcalibvalue(std::string value, int iid, std::string timestamp);
PGresult *getreadoutcalibvalues(std::string values, int iid, std::string timestamp);
double getreadoutcalibvalue(std::string value, std::string region, std::string readout, int axis, int layer, int VA, int channel, std::string timestamp);
PGresult *getreadoutcalibvalues(std::string values, std::string region, std::string readout, int axis, int layer, int VA, int channel, std::string timestamp);
double getreadoutcalibvalue(std::string value, std::string volname, std::string readout, std::string timestamp);
PGresult *getreadoutcalibvalues(std::string values, std::string volname, std::string readout, std::string timestamp);
PGresult *getreadoutstructure(std::string values, int iid);
std::string getsubdetector(int iid);
int getaxiscode(int iid);
int getlayercode(int iid);
int getvanumber(int iid);
int getchannel(int iid);

private:
std::string runinittimestr;
void exit_nicely();
void initconn();
PGconn *conn;
std::string calibversion;
std::string detectorversion;
std::string tsformatstring;
};
# 30 "./include/MDCSimulator.hh" 2
using namespace std;

const int N_GAIN = 4;
const int kDebug = 0;
const int N_VA = 29;
const int N_ChIMC = 33;
const int N_ChTASC = 16;

/* 140502 KS added *************************** from here */
const int N_TRIG_IMC =3;
const int N_TRIG_TASC =3;
const int N_TRIG_CHD =2;
const int N_TRIG_PATTERN=7;
const int kTrigIMCSngl =0;
const int kTrigIMCLow =1;
const int kTrigIMCHigh =2;
const int kTrigTASCSngl =0;
const int kTrigTASCLow =1;
const int kTrigTASCHigh =2;
const int kTrigCHDSngl =0;
const int kTrigCHDHeavy =1;
const int N_IMCFEC_LAYER = N_IMC_LAYER/2;
/* 140502 KS added *************************** till here */

struct OptionTeleOut_st {
  int dateMJD; // MJD Date to be processed
  int secSta; // Process start time in second
  int secProc; // Seconds to be processed
  int secDivN; // Number of division per second
  int gridM; // number of grids (M) for ATMNC3 output
  int testRun; // For test not to use DB, added by KS
  int oneOverN;//
  int trgFlag;//
  int frameType;//
  int zeroSup; //140520
  int buffer; //140619 TK
  int middleTransLimit; //140619 TK
  int noEvt; //140623
  int singleSelection; //140709 TK
  int restrictTransfer;
  const char* extension; // Add Extension to output file
  const char* orbitPath; // Geant4 Input  File Path (dat)
  const char* geant4Path; // Geant4 Output File Path (root)
  const char* ccsdsPath; // CCSDS  Binary File Path (dat)
  const char* settingPath;// MDC Setting File Path (cfg)
  const char* savePath; // MDC Save File Path (cfg)
};

struct CalibChannel_st {
  int id; // to retrieve assign information ???
  double delay;
  double zero_suppress_threshold;
  double pedestal;
  double pedestal_fluctuation;
  double charge_resolution;
  double conversion_adu_pe;
  double conversion_adu_charge;
  double conversion_adu_energy;
};

struct Calibration_st { // Holds Calibration Information
  // Readout Device ID 
  int chd_id[N_XY][N_CHD_BAR];
  int imc_id[N_XY][N_IMC_LAYER][N_IMC_FIBER];
  int tasc_id[N_XY][N_TASC_LAYER][N_TASC_LOG][N_GAIN];
  // Calibration Information for Each Channel
  struct CalibChannel_st chd[N_XY][N_CHD_BAR];
  struct CalibChannel_st imc[N_XY][N_IMC_LAYER][N_IMC_FIBER];
  struct CalibChannel_st tasc[N_XY][N_TASC_LAYER][N_TASC_LOG][N_GAIN];
  struct CalibChannel_st dynode[N_XY][N_IMC_LAYER/2];
  struct CalibChannel_st dummy[N_XY][N_IMC_LAYER/2][N_VA-1];
};

struct SimInfo_st { // Information of Simulation parameters
  UInt_t evtID;
  signed short pid;
  float energy;
  float zenith;
  float azimuth;
  float lat;
  float lon;
  float alt;

  float pos[N_XYZ];
  float dir[N_XYZ];

};

struct GSEHead_st {
  int addGSEHeader;
  int midORlow;
  int icsORnasa;
  int realORcor;
};

struct DBnumber_st {
  int xy;
  int layer;
  int va;
  int ch;
  //for IMC
  int posxy;
  int poslayer;
  int fiber;
};

struct Orbit_st {
  double t0;
  double t;
  int pid;
  double energy;
  double zenith;
  double azimuth;
  double lat;
  double lon;
  double alt;
  double vx;
  double vy;
  double vz;
};

struct CTRS_st {
  double CTRS_x;
  double CTRS_y;
  double CTRS_z;
  double CUradius;
  double Dist;
  double lonrad, latrad;
  double eccen;
  unsigned short int *CTRSbuf_up, *CTRSbuf_low;
  double P;
  double befDecrad, befCUradius;
};

struct J2000_st{
  double J2000_x;
  double J2000_y;
  double J2000_z;
  double alpha;
  double GST;
  double V_angular;
};

struct TimeCont_st{
  time_t MDCAllSec;
  int MDCyear;
  int MDCmonth;
  int MDCday;
  int MDChour;
  int MDCmin;
  int MDCsec;
  time_t GPSAllSec;
  int GPSyear;
  int GPSmonth;
  int GPSday;
  int GPShour;
  int GPSmin;
  int GPSsec;
  time_t UTCAllSec;
  int UTCyear;
  int UTCmonth;
  int UTCday;
  int UTChour;
  int UTCmin;
  int UTCsec;
  int MJD;
  int UTCtime_OD;
  int UTCDelay;

  struct tm *mt;
  struct tm *gt;
  struct tm *ut;
};

struct Event_st { // ADC Values
  int words;
  int hits;
  int chd[N_XY][N_CHD_BAR];
  int imc[N_XY][N_IMC_LAYER/2][N_VA][N_ChIMC];
  int tasc[N_XY][N_TASC_LAYER][N_TASC_LOG][N_GAIN];
};

struct ADCValue_st {
  int chd[N_XY][N_CHD_BAR];
  int imc[N_XY][N_IMC_LAYER][N_IMC_FIBER];
  int tasc[N_XY][N_TASC_LAYER][N_TASC_LOG][N_GAIN];
  int dynode[N_XY][N_IMC_LAYER/2];
  int dummy[N_XY][N_IMC_LAYER/2][N_VA];
};

struct Buf1Data_st{
  struct Event_st adc;

  UInt_t uniqueKey1Sec;
  UInt_t uniqueKey2;
  UInt_t uniqueKey3;
  UInt_t MDCTimeSec;
  UInt_t MDCTimeFrac;
  UInt_t eventID;

  UInt_t testPulseCHD;
  UInt_t testPulseIMC;
  UInt_t testPulseTASC;
  UInt_t triggerMaskExt;
  UInt_t triggerMaskHeavySingle;
  UInt_t triggerMaskHeavyLE;
  UInt_t triggerMaskHeavyHE;
  UInt_t triggerMaskSingle;
  UInt_t triggerMaskLE;
  UInt_t triggerMaskHE;
  UInt_t LDMaskCHD_SingleSingle[N_XY];
  UInt_t LDMaskCHD_SingleLow[N_XY];
  UInt_t LDMaskCHD_SingleHigh[N_XY];
  UInt_t LDMaskCHD_HeavySingle[N_XY];
  UInt_t LDMaskCHD_HeavyLow[N_XY];
  UInt_t LDMaskCHD_HeavyHigh[N_XY];
  UInt_t LDMaskIMC_Single[N_XY][N_IMC_LAYER/2];
  UInt_t LDMaskIMC_Low[N_XY][N_IMC_LAYER/2];
  UInt_t LDMaskIMC_High[N_XY][N_IMC_LAYER/2];
  UInt_t LDMaskTASC_Single;
  UInt_t LDMaskTASC_Low;
  UInt_t LDMaskTASC_High;

  UInt_t triggerMaskPed;
  UInt_t triggerHitExt;
  UInt_t triggerHitHeavySingle;
  UInt_t triggerHitHeavyLE;
  UInt_t triggerHitHeavyHE;
  UInt_t triggerHitSingle;
  UInt_t triggerHitLE;
  UInt_t triggerHitHE;

  UInt_t LDHitCHD_Single[N_XY];
  UInt_t LDHitCHD_Heavy[N_XY];
  UInt_t LDHitIMC_Single[N_XY][N_IMC_LAYER/2];
  UInt_t LDHitIMC_Low[N_XY][N_IMC_LAYER/2];
  UInt_t LDHitIMC_High[N_XY][N_IMC_LAYER/2];
  UInt_t LDHitTASC_Single;
  UInt_t LDHitTASC_Low;
  UInt_t LDHitTASC_High;
  UInt_t triggerCountSingle;
  UInt_t triggerCountLow;
  UInt_t triggerCountHigh;
  UInt_t triggerCountHeavySingle;
  UInt_t triggerCountHeavyLow;
  UInt_t triggerCountHeavyHigh;
  UInt_t countCHD_Single[N_XY];
  UInt_t countCHD_Heavy[N_XY];
  UInt_t countIMC_Single[N_XY][N_IMC_LAYER/2];
  UInt_t countIMC_Low[N_XY][N_IMC_LAYER/2];
  UInt_t countIMC_High[N_XY][N_IMC_LAYER/2];
  UInt_t countTASC_Single;
  UInt_t countTASC_Low;
  UInt_t countTASC_High;
  UInt_t countSingle;
  UInt_t countLE;
  UInt_t countHE;
  UInt_t countHeavySingle;
  UInt_t countHeavyLE;
  UInt_t countHeavyHE;
  UInt_t countTrigger;
};//added by TK 140503

struct MiddleBufData_st{
  UInt_t eventID;
  int dataLength;
  vector<signed short> *buf1;
  vector<signed short> *buf2;
};//added TK 140530


class MDCSimulator
{
public:

  /* 140113 added by KR *************************** from here */
  static const double Eradius = 6371.;//using type of coordinate system --> WGS84                
  static const double kSemimajor = 6378.137;
  static const double kSemiminor = 6356.752;
  static const double kLOD = 86400.0; //Length Of the Day                                         
  static const double kTimeOfRot = 86164.1;
  static const int kMJD_0=55500;
  static const int kMDCtimeOffset=86400*(365*30+7)+6 -315964800 +16; //30years&7days+6sec
  static const int kGPS_UTC_Offset=315964800; // in 2010/11/01/00:00
  static const int kUTCConst = 946771200;
  //static  const int GPSConst = 6;
  /* 140113 added by KR *************************** till here */

  static const int kGSEHeaderSize = 5; // in words
  static const int kCCSDSHeaderSize = 8; // in words
  static const int kUPDIPHeaderSize = 14; // in words // 140509 KS
  static const int kCRCSize = 2; // in words
  static const int kUniqueKeysWordsSize = 4; // in words // 140508 KS 
  static const int kUniqueKeysWordsSizeOld = 5; // in words // 140508 KS should be changed to 4.

  static const int kFragmentMaxNASA = 750; // 140509 KS
  static const int kFragmentMinNASA = 50; // 140509 KS
  static const int kFragmentMaxICS = 748; // 140509 KS
  static const int kFragmentMinICS = 24; // 140509 KS

  static const int kDebugMDC=0;

  static const double kJudgeFracSec = 0.1; //added TK 140702

  MDCSimulator(int modeHE, int modeLE, int modeSingle,
        int modeHeavyHE, int modeHeavyLE, int modeHeavySingle,
        int timeSec, int timeFrac, int unique2, int evtNo);

  MDCSimulator();
  MDCSimulator(string config);
  MDCSimulator(string MDCSettings, string SuccessionValues);
  MDCSimulator(MDCSimulator* mdc); // clone the instance // 140114 YAs

  ~MDCSimulator() {if (fEventBuf!=0) delete fEventBuf;}

  void Initialize();
  void CopyInstance(MDCSimulator* mdc);
  MDCSimulator* CloneInstance(); // 140114 YAs
  // void CopyVariables(MDCSimulator* mdc); // 140421 KS for Debug => debug done
  void MDCSaveState(ofstream &fout);
  void SetCalibValuesInit(CALETDBINT *DB);
  void SetCalibReadoutID(CALETDBINT *DB);
  void SetZeroSupressMode(int zeroSupMode){fZeroSupMode=zeroSupMode;}; // 140520 KS

  void UpdateCalibTables(CALETDBINT *DB);
  //void MakeTabHitPat(ofstream &fou, int &interactionFlag);
  void MakeTabHitPat(ofstream &fou, int &interactionFlag, int trgFlag);//131209 by KS
  void MakeTabHitPat(ofstream &fou, int &interactionFlag
       , int trgFlag, TIncidentParticle *inci);

  void SetCalibValues(CALETDBINT *DB);
  struct CalibChannel_st RetrieveCalibChannel(PGresult *res);
  string GetTestViewer(){
    string test = "Hello QL!";
    return test;
  };
  void SetOrbitData(Orbit_st orb) {
    fOrbit = orb;
    SetMDCTime();
  }; // 130727 YA
  void SetInciInfo(float posx,float posy,float posz,
     float dirx,float diry,float dirz)
  {
    fSimInfo.pos[kx]=posx;
    fSimInfo.pos[ky]=posy;
    fSimInfo.pos[kz]=posz;
    fSimInfo.dir[kx]=dirx;
    fSimInfo.dir[ky]=diry;
    fSimInfo.dir[kz]=dirz;
  }
  void SetMDCTime() { SetMDCTime(fOrbit.t0, fOrbit.t);};// 130727 YA
  void SetMDCTime(double t0, double t); // 130727 YA
  void SetUniqueKey1() { fUniqueKey1Sec = fMDCTimeSec;fUniqueKey1Frac = fMDCTimeFrac;};
  int GetDeadTimeState();//added by KS 130729
  void SetTrgValue(TCALData *data);
  void CalcTrigValue(TCALData *data);
  void SetHitInit();
  void SetADC2MIPIMC(TYACALData *data);//140527 KS tmp
  void SetADCValue(TCALData *data);
  void SetLDHit();
  void SetLDCounters();
  void SetTriggerHit();
  void TriggerDecision();
  void TriggerDecision(TCALData *data);//140708 TK
  void SetTriggerCounters();
  void SetTrigEffCounters(TIncidentParticle *inci, TCALGeometry *gGeo, int GeoType);
  int GeoCondDecision(TIncidentParticle *inci, TCALGeometry *gGeo, int GeoType);
  void ResetTriggerCounters();
  void ShowHits();
  void ShowHitsRead();
  void ShowAllADC();
  void ShowAllCounters();
  void ShowAllCountersPeriodic();
  void ShowTime();
  void ShowPosVector();
  void ShowAllCounters(ofstream& fou);
  UInt_t Triggered() {return fHitTrigger&&fGenEveData&&!fCheckFullBuf1;}
  void SetEventHitTime();



  void SetErrorEvent(int val) { fErrorEvent=val; } // 140423 YAs  
  //130113 add by KR from here-----
  //for Auxiliary Data
  double Rad2Deg(double rad);
  double Deg2Rad(double deg);
  void F32toUS16(double inCTRS, unsigned short int *buf1, unsigned short int *buf2);
  void Polar2Car();
  void Polar2Car(ofstream &fou);
  void Polar2Car(struct Orbit_st Orbit, struct CTRS_st &CTRS);
  void Car2Polar();
  void Car2Polar(ofstream &fou);
  void Car2Polar(struct CTRS_st CTRS, struct Orbit_st &Orbit);
  void J2000toCTRS();
  void J2000toCTRS(struct J2000_st J2000, struct CTRS_st &CTRS);
  void CTRStoJ2000();
  void CTRStoJ2000(struct CTRS_st CTRS, struct J2000_st &J2000);
  void SetAlpha();
  void SetAlpha(struct J2000_st &j2000);
  void SetAlphaLocal(struct J2000_st &J2000); // 140623 KS
  void SET_UTC_Time(); //for making CCSDS time information
  void SET_UTC_Time(int writeFlag); //for making CCSDS time information
  void SetUTCDelay();
  void SetUTCDelay(int &UTCDelay, UInt_t MDCTimeSec);
  void SetUTCDelay(int &UTCDelay);
  time_t GPS2UTC(time_t GPSsec);
  time_t UTC2GPS(time_t UTCsec);
  //130113 add by KR till here-----

  static signed short GetBit(signed short &word, Int_t n0, Int_t n){
    signed short d = 0;
    for(int i=0;i<n;i++) d = d | ((word & (1ULL << (n0+i))) >> n0) ;
    return d;
  }
  void SetReadSampleData() {fOffset13 = -1; fReadSampleMode = 1;} // 140502 YAs
  void SetReadSampleData(int flag) {
    if (flag==0) {
      fOffset13 = 0; fReadSampleMode = 0;
    } else if (flag==1) {
      fOffset13 = 0; fReadSampleMode = 1;
    } else if (flag==2) {
      fOffset13 = 1; fReadSampleMode = 2;
    } else {
      cerr << "ERROR OCCURED. Check Option for Read Data." << endl;
    }
  } // 140509 KS
  int GetOffset13() {return fOffset13;} // 140502 YAs

  static signed short GetBit(Int_t &word, Int_t n0, Int_t n){
    signed short d = 0;
    for(int i=0;i<n;i++) d = d | (signed short)((word & (1ULL << (n0+i))) >> n0) ;
    return d;
  }

  static Int_t GetInt(signed short &word, Int_t n0, Int_t n){
    Int_t d = 0;
    for(int i=0;i<n;i++) d = d | (Int_t)((word & (1ULL << (n0+i))) >> n0) ;
    return d;
  };

  static float GetFloat(signed short &w1, Int_t n1_0, Int_t n1,
   signed short &w2, Int_t n2_0, Int_t n2){
    union{
      float f;
      int i;
    }x;
    x.i=0;
    Int_t d1 = GetInt(w1,n1_0,n1);
    Int_t d2 = GetInt(w2,n2_0,n2);
    x.i = (d1<<n2) | d2;

    return x.f;
  };

  static signed short GetBit(float &word, Int_t n0, Int_t n){
    signed short d=0;
    union{
      float f;
      Int_t i;
    }x;
    x.f=word;
    //cerr<<"f  :"<<x.f<<endl;
    //cerr<<"f2i:"<<x.i<<endl;
    d = GetBit(x.i,n0,n);
    //cerr<<"res:"<<d<<endl;
    return d;
  };

  static unsigned short GetUShort(UInt_t word, Int_t n0, Int_t n){
    unsigned short d = 0;
    for(int i=0;i<n;i++) d = d | (unsigned short)((word & (1ULL << (n0+i))) >> n0) ;
    return d;
  }

  static unsigned short GetUShort(UInt_t w1, Int_t n1_0,Int_t n1,
      UInt_t w2, Int_t n2_0,Int_t n2){
    unsigned short d1 = GetUShort(w1, n1_0, n1);
    unsigned short d2 = GetUShort(w2, n2_0, n2);
    unsigned short d = (d1<<n2) | d2;
    return d;
  }

  static UInt_t GetUInt(signed short w1,Int_t n1_0,Int_t n1,
   signed short w2,Int_t n2_0,Int_t n2){
    UInt_t d1 = GetUInt(w1, n1_0, n1);
    UInt_t d2 = GetUInt(w2, n2_0, n2);
    UInt_t d = (d1<<n2) | d2;
    //cout <<Form("###%4.4x,%4.4x=>%8.8x %10d",d1,d2,d,d)<<endl;
    return d;
  }
  static UInt_t GetUInt(signed short word, Int_t n0, Int_t n){
    UInt_t d = 0;
    for(int i=0;i<n;i++) d = d | (UInt_t)((word & (1ULL << (n0+i))) >> n0) ;
    //cout <<Form("###%4.4x",d)<<endl;
    return d;
  }


  static Bool_t GetBit(signed short &word, Int_t n0){ return ((word & (1ULL << (n0))) >> n0); }
  static signed short GetBit(signed short &w1,Int_t n1_0,Int_t n1,
        signed short &w2,Int_t n2_0,Int_t n2){
    signed short d1 = GetBit(w1, n1_0, n1);
    signed short d2 = GetBit(w2, n2_0, n2);
    signed short d = (d1<<n2) | d2;
    return d;
  }

  ///--- 140426 YAs for Big Endian Data (from here) ---///
  static signed short GetBitBE(signed short word, Int_t n0, Int_t n){
    ByteSwap(&word, sizeof(word));
    signed short d = 0;
    for(int i=0;i<n;i++) d = d | ((word & (1ULL << (n0+i))) >> n0) ;
    return d;
  }

  static float GetFloatBE(signed short w1, Int_t n1_0, Int_t n1,
     signed short w2, Int_t n2_0, Int_t n2){
    ByteSwap(&w1, sizeof(w1));
    ByteSwap(&w2, sizeof(w2));
    union{
      float f;
      int i;
    }x;
    x.i=0;
    Int_t d1 = GetInt(w1,n1_0,n1);
    Int_t d2 = GetInt(w2,n2_0,n2);
    x.i = (d1<<n2) | d2;

    return x.f;
  };

  static unsigned short GetUShortBE(UInt_t word, Int_t n0, Int_t n){
    ByteSwap(&word, sizeof(word));
    unsigned short d = 0;
    for(int i=0;i<n;i++) d = d | (unsigned short)((word & (1ULL << (n0+i))) >> n0) ;
    return d;
  }

  static unsigned short GetUShortBE(UInt_t w1, Int_t n1_0,Int_t n1,
        UInt_t w2, Int_t n2_0,Int_t n2){
    ByteSwap(&w1, sizeof(w1));
    ByteSwap(&w2, sizeof(w2));
    unsigned short d1 = GetUShort(w1, n1_0, n1);
    unsigned short d2 = GetUShort(w2, n2_0, n2);
    unsigned short d = (d1<<n2) | d2;
    return d;
  }

  static UInt_t GetUIntBE(signed short w1,Int_t n1_0,Int_t n1,
     signed short w2,Int_t n2_0,Int_t n2){
    ByteSwap(&w1, sizeof(w1));
    ByteSwap(&w2, sizeof(w2));
    UInt_t d1 = GetUInt(w1, n1_0, n1);
    UInt_t d2 = GetUInt(w2, n2_0, n2);
    UInt_t d = (d1<<n2) | d2;
    //cout <<Form("###%4.4x,%4.4x=>%8.8x %10d",d1,d2,d,d)<<endl;
    return d;
  }
  static UInt_t GetUIntBE(signed short word, Int_t n0, Int_t n){
    ByteSwap(&word, sizeof(word));
    UInt_t d = 0;
    for(int i=0;i<n;i++) d = d | (UInt_t)((word & (1ULL << (n0+i))) >> n0) ;
    //cout <<Form("###%4.4x",d)<<endl;
    return d;
  }

  static Bool_t GetBitBE(signed short word, Int_t n0){
    ByteSwap(&word, sizeof(word));
    return ((word & (1ULL << (n0))) >> n0);
  }
  static signed short GetBitBE(signed short &w1,Int_t n1_0,Int_t n1,
          signed short &w2,Int_t n2_0,Int_t n2){
    ByteSwap(&w1, sizeof(w1));
    ByteSwap(&w2, sizeof(w2));
    signed short d1 = GetBit(w1, n1_0, n1);
    signed short d2 = GetBit(w2, n2_0, n2);
    signed short d = (d1<<n2) | d2;
    return d;
  }
  ///--- 140426 YAs for Big Endian Data (till here) ---///

  static time_t MDC2GPS(time_t MDCsec){
    time_t GPSsec=0;
    GPSsec = MDCsec;
    return GPSsec;
  }

  static time_t GPS2MDC(time_t GPSsec){
    time_t MDCsec=0;
    MDCsec = GPSsec;
    return MDCsec;
  }

  static time_t Date2Sec(struct tm date){
    time_t Sec;
    Sec = mktime(&date);
    return Sec;
  }

  static struct tm Sec2Date(time_t Sec){
    struct tm *date;
    date = gmtime(&Sec);
    return *date;
  }

  unsigned short GetUShortIMCAssign(Int_t axis, Int_t layer, Int_t va, Int_t ch){
    unsigned short d = 0;
    //cerr<<fCalID_IMC<<endl;
    d = GetUShort(fCalID_IMC,0,2) << 14 | GetUShort(fAxis[axis],0,1) << 13 |
      GetUShort(fLayer_IMC[layer],0,2) << 11 | GetUShort(fVAnum[va],0,5) << 6 |
      GetUShort(fCh_IMC[ch],0,6);
    if(kDebug==-3) cerr << d <<endl;
    return d;
  };
  unsigned short GetUShortTASC_PMTAssign(Int_t Ch){
    unsigned short d = 0;
    //cerr<<fCalID_TASC_PMT<<endl;
    d = GetUShort(fCalID_TASC_PMT,0,2) << 14 | GetUShort(fAxis[kX],0,1) << 13 |
      GetUShort(fLayer_TASC[0],0,3) << 10 | kFALSE<< 6 |
      GetUShort(fCh_TASC_PMT[Ch],0,6);
    if(kDebug==-3) cerr << d <<endl;
    return d;
  };
  unsigned short GetUShortTASC_PDAPDAssign(Int_t axis, Int_t layer, Int_t Ch){
    unsigned short d = 0;
    //cerr<<fCalID_TASC_PDAPD<<endl;
    d = GetUShort(fCalID_TASC_PDAPD,0,2) << 14 | GetUShort(fAxis[axis],0,1) << 13 |
      GetUShort(fLayer_TASC[layer],0,3) << 10 | kFALSE << 6 |
      GetUShort(fCh_TASC_PDAPD[Ch],0,6);
    if(kDebug==-3) cerr << d <<endl;
    return d;
  };
  unsigned short GetUShortCHDAssign(Int_t axis, Int_t Ch){
    unsigned short d = 0;
    d = GetUShort(fCalID_CHD,0,2) << 14 | GetUShort(fAxis[axis],0,1) << 13 |
      GetUShort(fLayer_CHD,0,3) << 10 | kFALSE << 6 |
      GetUShort(fCh_CHD[Ch],0,6);
    if(kDebug==-3) cerr << d <<endl;
    return d;
  };

  void SetRegValue();
  int RegularOut(int idiv) {
    // 130710 KS added
    if(idiv == 0)fRegularOut=1;
    else fRegularOut=0;
    return fRegularOut;
  };


  vector<vector<signed short>*> BuildRegularFrame(); // use fOrbit for orbit data
  vector<vector<signed short>*> BuildGPSRFrame();
  vector<vector<signed short>*> BuildSupportFrame();
  vector<vector<signed short>*> BuildEventFrame();
  vector<vector<signed short>*> BuildSimInfoFrame();
  void BufSetError(UInt_t chk, UInt_t siz);
  void FileOpen(FILE *fp, OptionTeleOut_st &opt, int isec, int idiv){
    /*    if((fp = fopen(Form("%s/M%2.2d/CR_MJD%5.5d_%5.5d_%2.2d.bin"
	  ,opt.ccsdsPath, opt.gridM, opt.dateMJD, opt.secSta+isec, idiv),"ab"))
	  == NULL ) {
	  cerr<<"cannot open file"<<endl;
	  return;
	  }*/
    fp = fopen(Form("%s/M%2.2d/CR_MJD%5.5d_%5.5d_%2.2d.bin"
      ,opt.ccsdsPath, opt.gridM, opt.dateMJD, opt.secSta+isec, idiv),"ab");
  };
  void FileClose(FILE *fp){fclose(fp);};
  void WriteBin(vector<vector<signed short>*> &frames, FILE *fp);
  void WriteCCSDS(vector<vector<signed short>*> &frames, FILE *fp);
  void WriteGSE(vector<vector<signed short>*> &frames, FILE *fp);
  void WriteIEEEHeader(FILE *fp,vector<vector<signed short>*> &frames, int &framenum);
  void WriteEventHeader(FILE *fp,vector<vector<signed short>*> &frames, int &frameNum);
  void WriteGSEHeader(FILE *fp,vector<vector<signed short>*> &frames, int &frameNum);
  void ReadBin(FILE *fp);
  void ReadCCSDS(FILE *fp);
  void ReadGSE(FILE *fp);
  void ReadIEEEHeader(FILE *fp);
  void ReadGSEHeader(FILE *fp);
  void Buf2DataDummy(FILE *fp);
  void Buf2Data0(FILE *fp);
  void Buf2Data1(FILE *fp);
  void Buf2Data4(FILE *fp);
  void Buf2Data5(FILE *fp);
  void Buf2Data6(FILE *fp);
  void Buf2Data10(FILE *fp);
  signed short* GetBuf(){return fBuf;};
  // 140108 YAs for QL --------------
  void ReadGSE(signed short* buff, int buffSize);
  //void ReadGSEDebug(signed short* buff, int buffSize);//140429 KS => very confusing, every time make mistake by editing original YAs
  void ReadGSEHeader(signed short* buff);
  void Buf2Data1(signed short* buf);
  void Buf2Data4(signed short* buf);
  void Buf2Data5(signed short* buf);
  void Buf2Data6(signed short* buf);
  //void Buf2Data6Debug(signed short* buf);//140429 KS => very confusing, every time make mistake by editing original YAs
  void Buf2Data10(signed short* buf);
  static void ShowBuffer(signed short *buf, int bufSize);
  static void ShowBuffer(char *buf, int bufSize);
  string SummarizeData1(); // 140111 YAs
  string SummarizeData6(); // 140111 YAs
  string SummarizeData6_10(); // 140111 YAs
  string SummarizeData10(); // 140111 YAs
  string SummarizeCheckSum(); // 140111 YAs

  // --------------------------------
  size_t fwriteLE2BE(signed short *buf, size_t size, size_t n, FILE *fp); //130901 KS
  size_t freadBE2LE(signed short *buf, size_t size, size_t n, FILE *fp); //130901 KS
  size_t fwriteLE2BE(float *buf, size_t size, size_t n, FILE *fp); //131012 KS
  size_t freadBE2LE(float *buf, size_t size, size_t n, FILE *fp); //131012 KS
  static int ByteSwap(void *buf, size_t type); //130901 KS
  //void Raw2Data(TCALData *data);//input raw ADC Data to TCALData. => 131216YAs not specified in .cc
  int GetUniqueKey1(){return fUniqueKey1Sec;};
  int GetUniqueKey2(){return fUniqueKey2;};
  int GetUniqueKey3(){return fUniqueKey3;};
  int GetTerminalFrame(){return fTerminalID;};
  int GetTerminalFile(){return fTerminalFile;};
  void InitializeADC(); //clear ADC for Read
  //void SetCalibValue();//for Read => 131216YAs not specified in .cc
  void SetForTestRun(Int_t kTestRun);//temporary
  void CheckCorrectAssignIMC(int &axis,int &layer,int &va,int &ch);
  void CheckCorrectAssignTASCPMT(int &axis,int &layer,int &ch);
  void CheckCorrectAssignTASCPDAPD(int &axis,int &layer,int &ch);
  void CheckCorrectAssignCHD(int &axis,int &layer,int &ch);
  void ExitOrThrough();//130821YA ### to check rev.H
  void ExitOrThrough(string mesg);//130821YA ### to check rev.H

  //int  GeoCondDecision(TIncidentParticle *inci, TCALGeometry *gGeo); 

  //void CalcCounter(int writeflag);//140503 KS
  //void CalcCounter();//140503 KS
  string GetPeriodicSummary(MDCSimulator *mdc1,
       MDCSimulator *mdc10,
       MDCSimulator *mdc100);// 140903 KS
  string GetMDCSettingSumTab1(); // 140903 KS
  string GetMDCSettingSumTab2(); // 140903 KS

  void GetPeriodicSummary(MDCSimulator *mdcfst, string &str1, string &str2);
  string ShowPeriodicSummary(MDCSimulator *mdcfst);//140506 KS //140507 KS modified

  //MDC Buffer
  void PushBuf1();//added by TK 140505
  void PopBuf1();//added by TK 140505
  MiddleBufData_st MiddleBuffer();//added TK 14058
  void PushMiddleBuf();
  void PopMiddleBuf();
  vector<vector<signed short>*>BuildEventFrame2();
  vector<vector<signed short>*>BuildEvent1stFrame();
  vector<vector<signed short>*>BuildEventRestWordFrame();
  vector<vector<signed short>*>BuildLastEventFrame();
  void JudgeWrite(FILE *fp);
  void SetUniqueKeys(vector<signed short> *buf,int termID,int fragmnt,int offset);//added Tk
  void SetBufTime(){
    fBufTimeSec=fMDCTimeSec;
    fBufTimeFrac=fMDCTimeFrac;
    cerr<<"#####Check Periodic:"<<fBufTimeSec<<" "<<fBufTimeFrac<<" "<<Form("%20f",(double)(fBufTimeSec+fBufTimeFrac*kUnitEventSecFrac))<<endl;
  };//TK
  void SetGSETime(){
    fGSETimeSec=fMDCTimeSec;
    fGSETimeFrac=fMDCTimeFrac;
  };
  void SetPeriodicOut(int num){fRegularOut=num;};//TK 141022
  void SetMiddleTransLimit(int middleTransLimit){fMiddleTransLimit=middleTransLimit;fMiddleTransLimitWord=middleTransLimit*100/16;};//added TK

  //SingleSelection
  void SingleSelection(TCALData *data);//added TK 140708
  void SetSingleSelectionMode(int singleSelectMode){fSingleSelectionMode=singleSelectMode;};//added TK 140708
  void SetBuffering(int buffer){fBuffering = buffer;};
  void SetFirstRestrictTime();
  void RestrictTransfer(vector<vector<signed short>*> &frames); //added by TK
  void SetRestrictTransfer(UInt_t restrictTransfer){fRestrictTransfer=restrictTransfer;};
  void SetGenRegData(UInt_t genRegData){fGenRegData=genRegData;};

  //  void ShowPeriodicSummary(MDCSimulator *mdcfst, string &str1, string &str2);
  // 140602 YAs created when merging with testMerge

  ///////////////////////////// GETTER ////////////////////////////////////
  int GetEvtBufSize() {return fEventBuf->size();} //140527 KS
  double GetMDCTime() {return (double)fMDCTimeSec + (double)fMDCTimeFrac*kUnitMDCSecFrac;}
  double GetEventTime() {return (double)fMDCTimeSec + (double)fMDCTimeFrac*kUnitEventSecFrac;}
  double GetGSETime() {return fGSETime;} //140117YAs
  UInt_t GetMDCTimeSec() {return fMDCTimeSec;}
  UInt_t GetMDCTimeFrac() {return fMDCTimeFrac;}
  UInt_t GetEventID() {return fEventID;}
  //130916 by KS
  UInt_t GetCountSingle() {return fCountSingle;}
  UInt_t GetCountHE() {return fCountHE;}
  UInt_t GetCountLE() {return fCountLE;}
  UInt_t GetCountHeavySingle() {return fCountHeavySingle;}
  UInt_t GetCountHeavyHE() {return fCountHeavyHE;}
  UInt_t GetCountHeavyLE() {return fCountHeavyLE;}
  UInt_t GetCountTrigger() {return fCountTrigger;} // 140115YAs added
  UInt_t GetCountCHDx_Single() {return fCountCHD_Single[kx];}
  UInt_t GetCountCHDy_Single() {return fCountCHD_Single[ky];}
  UInt_t GetCountCHDx_Heavy() {return fCountCHD_Heavy[kx];}
  UInt_t GetCountCHDy_Heavy() {return fCountCHD_Heavy[ky];}
  UInt_t GetCountIMCx1_Single(){return fCountIMC_Single[kx][0];}
  UInt_t GetCountIMCx2_Single(){return fCountIMC_Single[kx][1];}
  UInt_t GetCountIMCx3_Single(){return fCountIMC_Single[kx][2];}
  UInt_t GetCountIMCx4_Single(){return fCountIMC_Single[kx][3];}
  UInt_t GetCountIMCy1_Single(){return fCountIMC_Single[ky][0];}
  UInt_t GetCountIMCy2_Single(){return fCountIMC_Single[ky][1];}
  UInt_t GetCountIMCy3_Single(){return fCountIMC_Single[ky][2];}
  UInt_t GetCountIMCy4_Single(){return fCountIMC_Single[ky][3];}
  UInt_t GetCountIMCx1_High() {return fCountIMC_High[kx][0];}
  UInt_t GetCountIMCx2_High() {return fCountIMC_High[kx][1];}
  UInt_t GetCountIMCx3_High() {return fCountIMC_High[kx][2];}
  UInt_t GetCountIMCx4_High() {return fCountIMC_High[kx][3];}
  UInt_t GetCountIMCy1_High() {return fCountIMC_High[ky][0];}
  UInt_t GetCountIMCy2_High() {return fCountIMC_High[ky][1];}
  UInt_t GetCountIMCy3_High() {return fCountIMC_High[ky][2];}
  UInt_t GetCountIMCy4_High() {return fCountIMC_High[ky][3];}
  UInt_t GetCountIMCx1_Low() {return fCountIMC_Low[kx][0];}
  UInt_t GetCountIMCx2_Low() {return fCountIMC_Low[kx][1];}
  UInt_t GetCountIMCx3_Low() {return fCountIMC_Low[kx][2];}
  UInt_t GetCountIMCx4_Low() {return fCountIMC_Low[kx][3];}
  UInt_t GetCountIMCy1_Low() {return fCountIMC_Low[ky][0];}
  UInt_t GetCountIMCy2_Low() {return fCountIMC_Low[ky][1];}
  UInt_t GetCountIMCy3_Low() {return fCountIMC_Low[ky][2];}
  UInt_t GetCountIMCy4_Low() {return fCountIMC_Low[ky][3];}
  UInt_t GetCountTASC_Single() {return fCountTASC_Single;}
  UInt_t GetCountTASC_High() {return fCountTASC_High;}
  UInt_t GetCountTASC_Low() {return fCountTASC_Low;}

  UInt_t GetFragmentCounter() { return fFragmentCounter;} // 1400421 KS
  UInt_t GetFragmentCounterEv() { return fFragmentCounterEv;} // 1400430 KS
  UInt_t GetFragmentCounterEvLast() { return fFragmentCounterEvLast;} // 1400430 KS 
  UInt_t GetPacketsEvent() { return fFragmentCounterEv+1;} // 140129 YAs (byte)
  UInt_t GetDataSizeEvent() { return fDataSizeEvent;} // 140129 YAs (byte)
  UInt_t GetDataWordLen() { return fDataWordLen;} // 140129 YAs (byte)
  UInt_t GetTransferredFrames() {return fTransferredFrames;} // 140115 YAs
  UInt_t GetTransferredWords() {return fTransferredWords;} // 140115 YAs
  UInt_t GetErrorEvent() { return fErrorEvent; } // 140423 YAs
  UInt_t GetFrameLength() {return fFrameLength; }//added TK 140605

  void CalcPacketsRate(int dt, string place); // 140519 KS

  //Mask & Hit. 131004 by KS
  // -chd-
  UInt_t GetModeCHDx_SingleSingle() {return GetUInt(fLDMaskPattern3, 3,1);}
  UInt_t GetModeCHDy_SingleSingle() {return GetUInt(fLDMaskPattern3,11,1);}
  UInt_t GetModeCHDx_SingleLow() {return GetUInt(fLDMaskPattern3, 4,1);}
  UInt_t GetModeCHDy_SingleLow() {return GetUInt(fLDMaskPattern3,12,1);}
  UInt_t GetModeCHDx_SingleHigh() {return GetUInt(fLDMaskPattern3, 5,1);}
  UInt_t GetModeCHDy_SingleHigh() {return GetUInt(fLDMaskPattern3,13,1);}
  UInt_t GetModeCHDx_HeavySingle() {return GetUInt(fLDMaskPattern3, 0,1);}
  UInt_t GetModeCHDy_HeavySingle() {return GetUInt(fLDMaskPattern3, 8,1);}
  UInt_t GetModeCHDx_HeavyLow() {return GetUInt(fLDMaskPattern3, 1,1);}
  UInt_t GetModeCHDy_HeavyLow() {return GetUInt(fLDMaskPattern3, 9,1);}
  UInt_t GetModeCHDx_HeavyHigh() {return GetUInt(fLDMaskPattern3, 2,1);}
  UInt_t GetModeCHDy_HeavyHigh() {return GetUInt(fLDMaskPattern3,10,1);}
  UInt_t GetHitCHDx_Single() {return GetUInt(fLDHitPattern3, 8,1);}
  UInt_t GetHitCHDy_Single() {return GetUInt(fLDHitPattern3,10,1);}
  UInt_t GetHitCHDx_Heavy() {return GetUInt(fLDHitPattern3, 9,1);}
  UInt_t GetHitCHDy_Heavy() {return GetUInt(fLDHitPattern3,11,1);}

  UInt_t GetModeCHD_SingleSingle(Int_t xy) {return GetUInt(fLDMaskPattern3,3+xy*8,1);}
  UInt_t GetModeCHD_HeavySingle(Int_t xy) {return GetUInt(fLDMaskPattern3,0+xy*8,1);}
  UInt_t GetModeCHD_SingleLow(Int_t xy) {return GetUInt(fLDMaskPattern3,4+xy*8,1);}
  UInt_t GetModeCHD_HeavyLow(Int_t xy) {return GetUInt(fLDMaskPattern3,1+xy*8,1);}
  UInt_t GetModeCHD_SingleHigh(Int_t xy) {return GetUInt(fLDMaskPattern3,5+xy*8,1);}
  UInt_t GetModeCHD_HeavyHigh(Int_t xy) {return GetUInt(fLDMaskPattern3,2+xy*8,1);}
  UInt_t GetHitCHD_Single(Int_t xy) {return GetUInt(fLDHitPattern3,8+2*xy,1);}
  UInt_t GetHitCHD_Heavy(Int_t xy) {return GetUInt(fLDHitPattern3,9+2*xy,1);}
  // -imc-
  UInt_t GetModeIMCx1_High() {return GetUInt(fLDMaskPattern1,2,1);}
  UInt_t GetModeIMCy1_High() {return GetUInt(fLDMaskPattern2,2,1);}
  UInt_t GetModeIMCx1_Low() {return GetUInt(fLDMaskPattern1,1,1);}
  UInt_t GetModeIMCy1_Low() {return GetUInt(fLDMaskPattern2,1,1);}
  UInt_t GetModeIMCx1_Single() {return GetUInt(fLDMaskPattern1,0,1);}
  UInt_t GetModeIMCy1_Single() {return GetUInt(fLDMaskPattern2,0,1);}
  UInt_t GetHitIMCx1_High() {return GetUInt(fLDHitPattern1,2,1);}
  UInt_t GetHitIMCy1_High() {return GetUInt(fLDHitPattern2,2,1);}
  UInt_t GetHitIMCx1_Low() {return GetUInt(fLDHitPattern1,1,1);}
  UInt_t GetHitIMCy1_Low() {return GetUInt(fLDHitPattern2,1,1);}
  UInt_t GetHitIMCx1_Single() {return GetUInt(fLDHitPattern1,0,1);}
  UInt_t GetHitIMCy1_Single() {return GetUInt(fLDHitPattern2,0,1);}
  UInt_t GetModeIMCx2_High() {return GetUInt(fLDMaskPattern1,5,1);}
  UInt_t GetModeIMCy2_High() {return GetUInt(fLDMaskPattern2,5,1);}
  UInt_t GetModeIMCx2_Low() {return GetUInt(fLDMaskPattern1,4,1);}
  UInt_t GetModeIMCy2_Low() {return GetUInt(fLDMaskPattern2,4,1);}
  UInt_t GetModeIMCx2_Single() {return GetUInt(fLDMaskPattern1,3,1);}
  UInt_t GetModeIMCy2_Single() {return GetUInt(fLDMaskPattern2,3,1);}
  UInt_t GetHitIMCx2_High() {return GetUInt(fLDHitPattern1,5,1);}
  UInt_t GetHitIMCy2_High() {return GetUInt(fLDHitPattern2,5,1);}
  UInt_t GetHitIMCx2_Low() {return GetUInt(fLDHitPattern1,4,1);}
  UInt_t GetHitIMCy2_Low() {return GetUInt(fLDHitPattern2,4,1);}
  UInt_t GetHitIMCx2_Single() {return GetUInt(fLDHitPattern1,3,1);}
  UInt_t GetHitIMCy2_Single() {return GetUInt(fLDHitPattern2,3,1);}
  UInt_t GetModeIMCx3_High() {return GetUInt(fLDMaskPattern1,8,1);}
  UInt_t GetModeIMCy3_High() {return GetUInt(fLDMaskPattern2,8,1);}
  UInt_t GetModeIMCx3_Low() {return GetUInt(fLDMaskPattern1,7,1);}
  UInt_t GetModeIMCy3_Low() {return GetUInt(fLDMaskPattern2,7,1);}
  UInt_t GetModeIMCx3_Single() {return GetUInt(fLDMaskPattern1,6,1);}
  UInt_t GetModeIMCy3_Single() {return GetUInt(fLDMaskPattern2,6,1);}
  UInt_t GetHitIMCx3_High() {return GetUInt(fLDHitPattern1,8,1);}
  UInt_t GetHitIMCy3_High() {return GetUInt(fLDHitPattern2,8,1);}
  UInt_t GetHitIMCx3_Low() {return GetUInt(fLDHitPattern1,7,1);}
  UInt_t GetHitIMCy3_Low() {return GetUInt(fLDHitPattern2,7,1);}
  UInt_t GetHitIMCx3_Single() {return GetUInt(fLDHitPattern1,6,1);}
  UInt_t GetHitIMCy3_Single() {return GetUInt(fLDHitPattern2,6,1);}
  UInt_t GetModeIMCx4_High() {return GetUInt(fLDMaskPattern1,11,1);}
  UInt_t GetModeIMCy4_High() {return GetUInt(fLDMaskPattern2,11,1);}
  UInt_t GetModeIMCx4_Low() {return GetUInt(fLDMaskPattern1,10,1);}
  UInt_t GetModeIMCy4_Low() {return GetUInt(fLDMaskPattern2,10,1);}
  UInt_t GetModeIMCx4_Single() {return GetUInt(fLDMaskPattern1,9,1);}
  UInt_t GetModeIMCy4_Single() {return GetUInt(fLDMaskPattern2,9,1);}
  UInt_t GetHitIMCx4_High() {return GetUInt(fLDHitPattern1,11,1);}
  UInt_t GetHitIMCy4_High() {return GetUInt(fLDHitPattern2,11,1);}
  UInt_t GetHitIMCx4_Low() {return GetUInt(fLDHitPattern1,10,1);}
  UInt_t GetHitIMCy4_Low() {return GetUInt(fLDHitPattern2,10,1);}
  UInt_t GetHitIMCx4_Single() {return GetUInt(fLDHitPattern1,9,1);}
  UInt_t GetHitIMCy4_Single() {return GetUInt(fLDHitPattern2,9,1);}
  UInt_t GetLDHitPattern1() {return fLDHitPattern1;}
  UInt_t GetLDHitPattern2() {return fLDHitPattern2;}
  UInt_t GetLDHitPattern3() {return fLDHitPattern3;}
  UInt_t GetLDMaskPattern1() {return fLDMaskPattern1;}
  UInt_t GetLDMaskPattern2() {return fLDMaskPattern2;}
  UInt_t GetLDMaskPattern3() {return fLDMaskPattern3;}
  UInt_t GetTriggerHitPattern() {return fTriggerHitPattern;}
  UInt_t GetTriggerMaskPattern() {return fTriggerMaskPattern;}

  UInt_t GetModeIMC_High(Int_t xy, Int_t pos) {
    UInt_t tmpMode = 99999;
    if(xy==0) tmpMode = GetUInt(fLDMaskPattern1,3*pos+2,1);
    else if(xy==1) tmpMode = GetUInt(fLDMaskPattern2,3*pos+2,1);
    else {
      cerr << "Error! input 0 or 1 to Axis Num." << endl;
      return -1;
    }
    if(pos<0 || pos >3) {
      cerr << "Error! input 0 ~ 4 to Layer Num." << endl;
      return -1;
    }
    return tmpMode;
  }
  UInt_t GetModeIMC_Low(Int_t xy, Int_t pos) {
    UInt_t tmpMode = 99999;
    if(xy==0) tmpMode = GetUInt(fLDMaskPattern1,3*pos+1,1);
    else if(xy==1) tmpMode = GetUInt(fLDMaskPattern2,3*pos+1,1);
    else {
      cerr << "Error! input 0 or 1 to Axis Num." << endl;
      return -1;
    }
    if(pos<0 || pos >3) {
      cerr << "Error! input 0 ~ 4 to Layer Num." << endl;
      return -1;
    }
    return tmpMode;
  }
  UInt_t GetModeIMC_Single(Int_t xy, Int_t pos) {
    UInt_t tmpMode = 99999;
    if(xy==0) tmpMode = GetUInt(fLDMaskPattern1,3*pos,1);
    else if(xy==1) tmpMode = GetUInt(fLDMaskPattern2,3*pos,1);
    else {
      cerr << "Error! input 0 or 1 to Axis Num." << endl;
      return -1;
    }
    if(pos<0 || pos >3) {
      cerr << "Error! input 0 ~ 4 to Layer Num." << endl;
      return -1;
    }
    return tmpMode;
  }
  UInt_t GetHitIMC_High(Int_t xy, Int_t pos) {
    UInt_t tmpHit = 99999;
    if(xy==0) tmpHit = GetUInt(fLDHitPattern1,3*pos+2,1);
    else if(xy==1) tmpHit = GetUInt(fLDHitPattern2,3*pos+2,1);
    else {
      cerr << "Error! input 0 or 1 to Axis Num." << endl;
      return -1;
    }
    if(pos<0 || pos >3) {
      cerr << "Error! input 0 ~ 4 to Layer Num." << endl;
      return -1;
    }
    return tmpHit;
  }
  UInt_t GetHitIMC_Low(Int_t xy, Int_t pos) {
    UInt_t tmpHit = 99999;
    if(xy==0) tmpHit = GetUInt(fLDHitPattern1,3*pos+1,1);
    else if(xy==1) tmpHit = GetUInt(fLDHitPattern2,3*pos+1,1);
    else {
      cerr << "Error! input 0 or 1 to Axis Num." << endl;
      return -1;
    }
    if(pos<0 || pos >3) {
      cerr << "Error! input 0 ~ 4 to Layer Num." << endl;
      return -1;
    }
    return tmpHit;
  }
  UInt_t GetHitIMC_Single(Int_t xy, Int_t pos) {
    UInt_t tmpHit = 99999;
    if(xy==0) tmpHit = GetUInt(fLDHitPattern1,3*pos,1);
    else if(xy==1) tmpHit = GetUInt(fLDHitPattern2,3*pos,1);
    else {
      cerr << "Error! input 0 or 1 to Axis Num." << endl;
      return -1;
    }
    if(pos<0 || pos >3) {
      cerr << "Error! input 0 ~ 4 to Layer Num." << endl;
      return -1;
    }
    return tmpHit;
  }
  // -tasc-
  UInt_t GetModeTASC_High() {return GetUInt(fLDMaskPattern1,14,1);}
  UInt_t GetModeTASC_Low() {return GetUInt(fLDMaskPattern1,13,1);}
  UInt_t GetModeTASC_Single() {return GetUInt(fLDMaskPattern1,12,1);}
  UInt_t GetHitTASC_High() {return GetUInt(fLDHitPattern3,2,1);}
  UInt_t GetHitTASC_Low() {return GetUInt(fLDHitPattern3,1,1);}
  UInt_t GetHitTASC_Single() {return GetUInt(fLDHitPattern3,0,1);}

  // -Triggers-
  UInt_t GetHitHE() {return GetUInt(fTriggerHitPattern,2,1);}
  UInt_t GetHitLE() {return GetUInt(fTriggerHitPattern,1,1);}
  UInt_t GetHitSingle() {return GetUInt(fTriggerHitPattern,0,1);}
  UInt_t GetHitHeavyHE() {return GetUInt(fTriggerHitPattern,5,1);}
  UInt_t GetHitHeavyLE() {return GetUInt(fTriggerHitPattern,4,1);}
  UInt_t GetHitHeavySingle() {return GetUInt(fTriggerHitPattern,3,1);}
  UInt_t GetHitTrigger() {return fHitTrigger;}
  UInt_t GetHitExt() {return GetUInt(fTriggerHitPattern,14,1);}
  UInt_t GetModePedTrig() {return GetUInt(fTriggerHitPattern,15,1);}
  UInt_t GetModeHE() {return GetUInt(fTriggerMaskPattern,2,1);}
  UInt_t GetModeLE() {return GetUInt(fTriggerMaskPattern,1,1);}
  UInt_t GetModeSingle() {return GetUInt(fTriggerMaskPattern,0,1);}
  UInt_t GetModeHeavyHE() {return GetUInt(fTriggerMaskPattern,5,1);}
  UInt_t GetModeHeavyLE() {return GetUInt(fTriggerMaskPattern,4,1);}
  UInt_t GetModeHeavySingle() {return GetUInt(fTriggerMaskPattern,3,1);}
  UInt_t GetModeExt() {return GetUInt(fTriggerMaskPattern,6,1);}

  // Get Deadtime
  UInt_t GetDeadTimeCount() { return fCountDeadTime;}
  double GetDeadTime() { return fCountDeadTime*kUnitEventSecFrac;} //[sec] 140507 YAs
  static double GetUnitEventSecFrac() {return kUnitEventSecFrac;}; //[sec] 140507 YAs

  //Get Buf Usage

  UInt_t GetBuf1UsageRate(){return f1stTransCALDataBufUsage;}
  UInt_t GetMiddleBufUsageRate(){return fMedTransCALDataBufUsage;}

  // Get Values. 
  struct ADCValue_st GetADCValues() {return fADCValue;}
  struct Calibration_st GetCalibValues() {return fCalib;}
  struct SimInfo_st GetSimInfo() {return fSimInfo;}
  int GetPMTSumCHD(int xy) {
    int sum=0;
    int cnt=0;
    for(int i=0;i<N_CHD_BAR;i++) {
      if(fADCValue.chd[xy][i]==-65536){cnt++; continue;}
      sum+=(fADCValue.chd[xy][i]-fCalib.chd[xy][i].pedestal);
    }
    if(cnt==N_CHD_BAR)sum=-65536;
    return sum;
  }
  int GetDynodeSum(int xy, int layer) {
    int val = fADCValue.dynode[xy][layer] - fCalib.dynode[xy][layer].pedestal;
    return val;
  }
  int GetPMTSumTASC() {
    int sum=0;
    int cnt=0;
    for(int i=0;i<N_TASC_LOG;i++) {
      if(fADCValue.tasc[0][0][i][0]==-65536){cnt++; continue;}
      sum+=(fADCValue.tasc[0][0][i][0]-fCalib.tasc[0][0][i][0].pedestal);
    }
    if(cnt==N_TASC_LOG)sum=-65536;
    return sum;
  }

  //130113 add by KR from here----------
  struct Orbit_st GetOrbit() {return fOrbit;}
  struct CTRS_st GetCTRS() {return fCTRS;}
  struct J2000_st GetJ2000() {return fJ2000;}
  struct TimeCont_st GetTCont() {return fTCont;}
  //130113 add by KR till here----------
  UInt_t GetOnTimeyear() {return fOnTimeYear;}
  UInt_t GetOnTimemonth(){return fOnTimeMon;}
  UInt_t GetOnTimeday() {return fOnTimeDay;}
  UInt_t GetOnTimehour() {return fOnTimeHour;}
  UInt_t GetOnTimemin() {return fOnTimeMin;}
  UInt_t GetOnTimesec() {return fOnTimeSec;}

  UInt_t GetUTCyear() {return fUTCyear;}
  UInt_t GetUTCmonth(){return fUTCmonth;}
  UInt_t GetUTCday() {return fUTCday;}
  UInt_t GetUTChour() {return fUTChour;}
  UInt_t GetUTCmin() {return fUTCmin;}
  UInt_t GetUTCsec() {return fUTCsec;}

  void SetUTCTime(int year, int month, int day,
    int hour, int min, int sec) {
    SetUTCyear(year);
    SetUTCmonth(month);
    SetUTCday(day);
    SetUTChour(hour);
    SetUTCmin(min);
    SetUTCsec(sec);
    /*cerr << Form("UTC(MDC)::%04d/%02d/%02d/%02d/%02d:%02d"
      ,year,month,day,hour,min,sec) << endl;*/
  }
  void SetUTCyear(int year) {fTCont.UTCyear=year;}
  void SetUTCmonth(int month){fTCont.UTCmonth=month;}
  void SetUTCday(int day) {fTCont.UTCday=day;}
  void SetUTChour(int hour) {fTCont.UTChour=hour;}
  void SetUTCmin(int min) {fTCont.UTCmin=min;}
  void SetUTCsec(int sec) {fTCont.UTCsec=sec;}

  double GetMIP_chd() {return MIP_chd;}
  double GetMIP_imc() {return MIP_imc;}
  double GetMIP_tasc(Int_t gain) {return MIP_tasc[gain];}

  void SetGSEHeadInfo(int midORlow, int icsORnasa, int realORcor){
    fGSEHead.midORlow =midORlow;
    fGSEHead.icsORnasa=icsORnasa;
    fGSEHead.realORcor=realORcor;
    fGSEHead.addGSEHeader=1;//GSE On
    if(icsORnasa==0)fMidTransFormat=1;
    else if(icsORnasa==1)fMidTransFormat=0;
  };

  void SetCCSDSOn(){fGSEHead.addGSEHeader=0;} //CCSDS On

  bool IsMCData() {return fMCDataFlag; } // 140507 YAs
  double GetLatitude() {return fLatitude; } // 140507 YAs
  double GetLongitude() {return fLongitude; } // 140507 YAs
  double GetAltitude() {return fAltitude; } // 140507 YAs

  void SetAddMode(int flag){fAddFlag=flag;}; // 140708 KS

private:

  struct ADCValue_st fADCValue;
  struct Calibration_st fCalib;
  struct SimInfo_st fSimInfo;
  struct GSEHead_st fGSEHead;//added by KS 131212
  //MIP for Display
  double MIP_chd;// (ADC/1MIP)
  double MIP_imc;// (ADC/1MIP)
  double MIP_tasc[N_GAIN];// (ADC/1MIP)

  static const int kUniqueKey3REG = 1;
  static const int kUniqueKey3GPS = 4;
  static const int kUniqueKey3SUP = 5;
  static const int kUniqueKey3CAL = 6;
  static const int kUniqueKey3SimInfo =10;
  static const double kDeadTimeDAQ = 5.8e-3;
  static const int kLenCRC = 2;

  static const double kUnitMDCSecFrac = 62.5*1.0e-6; // [sec] 140507 KS
  static const double kUnitEventSecFrac = 62.5/4*1.0e-6; // [sec] 140507 KS

  static const double kPacketSendFrac=0.0008; //(byte)//added TK 140530
  static const UInt_t kMiddleBufSize=5000000; //(byte)//added TK 140530
  //   static const UInt_t kMiddleBufSize=10000;//(byte) //added TK 140530
  int fZeroSupMode;
  int fAddFlag; //140708 KS

  // Regular Output
  int fRegularOut;
  struct Orbit_st fOrbit;

  //130113 add by KR from here------
  struct CTRS_st fCTRS;
  struct J2000_st fJ2000;
  struct TimeCont_st fTCont;
  //130113 add by KR till here------

  // --- MDC Time
  UInt_t fMDCTimeSec; // in unit sec
  UInt_t fMDCTimeFrac; // in unit of 62.5us
  UInt_t fUniqueKey1Sec; // basically same as fMDCTimeSec
  UInt_t fUniqueKey1Frac; // basically same as fMDCTimeSec
  UInt_t fUniqueKey2; // counter
  UInt_t fUniqueKey3; // added by KS 130721
  UInt_t fPacketLength; // added by KS 130730
  UInt_t fEventHitTimeSec; //added by KS 130729
  UInt_t fEventHitTimeFrac; //added by KS 130729

  Int_t fUTCDelay; // 140705 KS

  time_t kTimer;

  // --- Data Broadcast Time 140502 KS
  UInt_t fOnTimeYear;
  UInt_t fOnTimeMon;
  UInt_t fOnTimeDay;
  UInt_t fOnTimeHour;
  UInt_t fOnTimeMin;
  UInt_t fOnTimeSec;
  UInt_t fOnTimemSec;

  // --- MDC Status 140502 KS
  UInt_t fMDCOperationStatus;
  UInt_t fMDCErrorCounter;
  UInt_t fIsOnTimeAcquisition;

  // --- Data Translate 140502 KS
  UInt_t fLowTransLimit;
  UInt_t fMidTransFormat;
  UInt_t fMiddleTransLimit;

  UInt_t fLowTransCALDataOutCoef;
  UInt_t fMiddleTransCALDataOutCoef;

  // --- FEC Status 140502 KS
  UInt_t fStatusCHD[N_XY]; //1-515
  UInt_t fStatusIMC[N_XY][N_IMC_LAYER/2]; //1-480-481
  UInt_t fStatusTASC[N_XY][N_TASC_LAYER]; //1-508-510

  // --- Zero Supress 140502 KS
  UInt_t fZeroSupressFileNoIMC[N_XY][N_IMC_LAYER/2]; //1-299,300
  UInt_t fZeroSupressFileNoCHD; //1-301
  UInt_t fZeroSupressFileNoTASC; //1-301


  UInt_t fLDInhibitIMC[N_XY][N_IMC_LAYER/2]; //1-394-401
  UInt_t fLDThresholdIMC[N_XY][N_IMC_LAYER/2][N_TRIG_IMC]; //1-402-413
  UInt_t fLDInhibitTASC; //1-482
  UInt_t fLDThresholdTASC[N_TRIG_TASC]; //1-483-484
  UInt_t fLDInhibitCHD[N_XY]; //1-511,512
  UInt_t fLDThresholdCHD[N_XY][N_TRIG_CHD]; //1-513,514
  UInt_t fOverNTrig; //1-517
  UInt_t fPedTrigStatus; //1-517
  UInt_t fExtTrigInhibit; //1-521
  //  UInt_t   fMiddleTransCALDataBufStat;                        //1-537
  UInt_t fMedTransCALDataBufUsage; //1-537 //changed TK 140903
  //UInt_t   fLowTransCALDataBufStat;                           //1-537
  UInt_t fLowTransCALDataBufUsage; //1-537
  //  UInt_t   f1stTransCALDataBufStat;                           //1-538
  UInt_t f1stTransCALDataBufUsage; //1-538 //changed TK 140903
  UInt_t fIsSnglSelection; //1-517 140502 KS
  UInt_t fTrigMaskPattern; //1-526

  // --- for Show Periodic Summary
  UInt_t fEventCounter;
  UInt_t fEventCountDelta[3];
  UInt_t fIncompleteCounter;
  UInt_t fEventSizeCounterCHD;
  UInt_t fEventSizeCounterIMC;
  UInt_t fEventSizeCounterTASC;
  UInt_t fEventSizeCounter;
  UInt_t fTimeOutCounterCHD;
  UInt_t fTimeOutCounterIMC;
  UInt_t fTimeOutCounterTASC;
  UInt_t fTimeOutCounter;
  UInt_t fParityErrCounterCHD;
  UInt_t fParityErrCounterIMC;
  UInt_t fParityErrCounterTASC;
  UInt_t fParityErrCounter;
  UInt_t f0MDCTime1;
  UInt_t f1MDCTime1;
  UInt_t f0MDCTime2;
  UInt_t f1MDCTime2;

  UInt_t fMiddleTransCALDataBufMax;
  UInt_t fLowTransCALDataBufMax;
  UInt_t f1stTransCALDataBufMax;

  UInt_t fIsFirstADC_CHD;
  UInt_t fIsFirstADC_IMC;
  UInt_t fIsFirstADC_IDYN;
  UInt_t fIsFirstADC_TASC;
  UInt_t fIsOtherADC_CHD;
  UInt_t fIsOtherADC_IMC;
  UInt_t fIsOtherADC_IDYN;
  UInt_t fIsOtherADC_TASC;
  UInt_t fIsTASCADCErrAll;
  UInt_t fIsOverlapEventIDAll;


  // --- Dead 
  double fDeadTime; // added by KS 130729
  // --- GSE Time
  double fGSETime; // in unit sec 140117YAs
  UInt_t fGSETimeSec;//add TK 141002
  UInt_t fGSETimeFrac;//add TK 141002
  // --- Frame Control
  int fTerminalID; // added by KS 130721    // renamed 130727 YA
  int fTerminalFile; // added by KS 130723  // renamed 130727 YA
  int fFrameLength; // added by KS 130723   // renamed 130727 YA
  int fFragmentCounter; // added by KS 130721 // renamed 130727 YA
  int fFragmentCounterEv; // added by KS 140430
  int fFragmentCounterEvLast; // added by KS 140430
  int fErrorEvent; // 140423 YAs 0: normal, 1:size error, ...
  int fNotFirstFrameFlag; //140429 KS

  int fReadSampleMode; //140430 KS


  // --- Event ID
  UInt_t fEventID;

  // Dynode Signal
  double IMC_Trig[N_XY][N_IMC_LAYER/2];
  double CHD_Trig[N_XY];
  double TASC_Trig;
  double IMC_Edep[N_XY];
  double CHD_Edep[N_XY];
  double TASC_Edep;

  // LD Counter
  UInt_t fCountIMC_High[N_XY][N_IMC_LAYER/2];
  UInt_t fCountIMC_Low[N_XY][N_IMC_LAYER/2];
  UInt_t fCountIMC_Single[N_XY][N_IMC_LAYER/2];
  UInt_t fCountCHD_Single[N_XY];
  UInt_t fCountCHD_Heavy[N_XY];
  UInt_t fCountTASC_High;
  UInt_t fCountTASC_Low;
  UInt_t fCountTASC_Single;

  // Trigger Counter
  UInt_t fCountHE;
  UInt_t fCountLE;
  UInt_t fCountSingle;
  UInt_t fCountHeavyHE;
  UInt_t fCountHeavyLE;
  UInt_t fCountHeavySingle;
  UInt_t fCountTrigger;

  UInt_t fCountPassedHE;
  UInt_t fCountPassedLE;
  UInt_t fCountPassedSingle;
  UInt_t fCountPassedHeavyHE;
  UInt_t fCountPassedHeavyLE;
  UInt_t fCountPassedHeavySingle;
  UInt_t fCountPassedAll;

  // Deadtime Counter
  UInt_t fCountDeadTime;

  // Bandwidth Monitor 140115YAs added
  UInt_t fTransferredWords;
  UInt_t fTransferredFrames;

  UInt_t fTriggerHitPattern;
  UInt_t fTriggerMaskPattern;
  // LD/Trigger Hit Pattern
  UInt_t fLDHitPattern1;
  UInt_t fLDHitPattern2;
  UInt_t fLDHitPattern3;
  UInt_t fHitIMC_High[N_XY][N_IMC_LAYER/2];
  UInt_t fHitIMC_Low[N_XY][N_IMC_LAYER/2];
  UInt_t fHitIMC_Single[N_XY][N_IMC_LAYER/2];
  UInt_t fHitCHD_Single[N_XY];
  UInt_t fHitCHD_SingleSingle[N_XY];
  UInt_t fHitCHD_SingleHigh[N_XY];
  UInt_t fHitCHD_SingleLow[N_XY];
  UInt_t fHitCHD_Heavy[N_XY];
  UInt_t fHitCHD_HeavySingle[N_XY];
  UInt_t fHitCHD_HeavyHigh[N_XY];
  UInt_t fHitCHD_HeavyLow[N_XY];
  UInt_t fHitTASC_High;
  UInt_t fHitTASC_Low;
  UInt_t fHitTASC_Single;
  UInt_t fHitHE;
  UInt_t fHitLE;
  UInt_t fHitSingle;
  UInt_t fHitHeavyHE;
  UInt_t fHitHeavyLE;
  UInt_t fHitHeavySingle;
  UInt_t fHitTrigger;
  UInt_t fHitExt; //added by KS 130711

  // Trigger Masks (0: Masked, 1:Active)
  UInt_t fLDMaskPattern1;
  UInt_t fLDMaskPattern2;
  UInt_t fLDMaskPattern3;
  UInt_t fModeIMC_High[N_XY][N_IMC_LAYER/2];
  UInt_t fModeIMC_Low[N_XY][N_IMC_LAYER/2];
  UInt_t fModeIMC_Single[N_XY][N_IMC_LAYER/2];
  UInt_t fModeCHD_SingleSingle[N_XY];
  UInt_t fModeCHD_HeavySingle[N_XY];
  UInt_t fModeCHD_SingleLow[N_XY];
  UInt_t fModeCHD_HeavyLow[N_XY];
  UInt_t fModeCHD_SingleHigh[N_XY];
  UInt_t fModeCHD_HeavyHigh[N_XY];
  UInt_t fModeTASC_High;
  UInt_t fModeTASC_Low;
  UInt_t fModeTASC_Single;
  //LD Threshold
  double fThresholdIMC_High[N_XY][N_IMC_LAYER/2];
  double fThresholdIMC_Low[N_XY][N_IMC_LAYER/2];
  double fThresholdIMC_Single[N_XY][N_IMC_LAYER/2];
  double fThresholdCHD_Single[N_XY];
  double fThresholdCHD_Heavy[N_XY];
  double fThresholdTASC_High;
  double fThresholdTASC_Low;
  double fThresholdTASC_Single;
  //LD MIP2Bit Conversion Factor
  double fMIP2BitIMC_High[N_XY][N_IMC_LAYER/2];
  double fMIP2BitIMC_Low[N_XY][N_IMC_LAYER/2];
  double fMIP2BitIMC_Single[N_XY][N_IMC_LAYER/2];
  double fMIP2BitCHD_Single[N_XY];
  double fMIP2BitCHD_Heavy[N_XY];
  double fMIP2BitTASC_High;
  double fMIP2BitTASC_Low;
  double fMIP2BitTASC_Single;

  UInt_t fModePedTrig;
  UInt_t fModeHE;
  UInt_t fModeLE;
  UInt_t fModeSingle;
  UInt_t fModeHeavyHE;
  UInt_t fModeHeavyLE;
  UInt_t fModeHeavySingle;
  UInt_t fModeExt; //added by KS 130711

  //Test Pattern for SingleSelection //added by TK 140716
  UInt_t fTestIMC_Single[N_XY][N_IMC_LAYER/2];
  UInt_t fTestIMC_Low[N_XY][N_IMC_LAYER/2];
  UInt_t fTestIMC_High[N_XY][N_IMC_LAYER/2];
  UInt_t fTestTASC_Single;
  UInt_t fTestTASC_Low;
  UInt_t fTestTASC_High;
  UInt_t fTestPattern_IMC[N_XY];
  UInt_t fTestPattern_TASC;

  //RestriceTransfer
  double fKillTime;
  UInt_t fKillTimeState;
  double fRestrictTimeSec;
  double fRestrictTimeFrac;
  double fDataSize;
  UInt_t fRestrictTransfer;

  UInt_t fDataWordLen; //added by KS 130815
  UInt_t fDataWordLenCheck; //added by YA 130820
  UInt_t fDataSizeEvent; // 140129 YAs
  signed short fCheckSum; //added by KS 130815
  signed short fCheckSumRec; //added by YAs 140110
  UInt_t fOddNumFlag;

  bool fMCDataFlag;
  double fLatitude;
  double fLongitude;
  double fAltitude;

  struct Event_st fEvent;

  // CAL ID
  int fCalID_IMC; //00
  int fCalID_TASC_PMT; //01
  int fCalID_TASC_PDAPD; //10
  int fCalID_CHD; //11

  //for Auxiliary Data by KR from here----
  UInt_t fUTCyear;
  UInt_t fUTCmonth;
  UInt_t fUTCday;
  UInt_t fUTChour;
  UInt_t fUTCmin;
  UInt_t fUTCsec;
  //for Auxiliary Data by KR till here----

  // Axis Code
  int fAxis[N_XY];
  // Layer Code
  int fLayer_IMC[N_IMC_LAYER/2];
  int fLayer_TASC[N_TASC_LAYER];
  int fLayer_CHD;
  // VA Number
  int fVAnum[29]; //0=VA01,..., 27=VA28, 28=DynodeSum
  //Channel Number IMC
  int fCh_IMC[33]; //0=Ch1,..., 31=Ch32, 32=dummyCh
  //Channel Number TASC_PMT
  int fCh_TASC_PMT[16]; //0=PMT1,..., 15=PMT16
  //Channel Number TASC_PDAPD
  int fCh_TASC_PDAPD[16]; //0=PD/APD1,..., 15=PD/APD16
  //Channel Number CHD
  int fCh_CHD[14]; //0=PMT1,..., 13=PMT14

  struct DBnumber_st fCHDnum[N_XY][N_CHD_BAR];
  struct DBnumber_st fIMCnum[N_XY][N_IMC_LAYER][N_IMC_FIBER];
  struct DBnumber_st fIMCPosnum[N_XY][N_IMC_LAYER/2][N_VA][N_ChIMC];//
  struct DBnumber_st fTASCnum[N_XY][N_TASC_LAYER][N_TASC_LOG][N_GAIN];




  vector<signed short> *fEventBuf;
  int fOffset13; // Offset Value to skip DataNo=13

  signed short* fBuf; //140708 KS
  UInt_t fBuffering;
  queue<Buf1Data_st> fBuf1;
  queue<MiddleBufData_st> fMiddleBuf;
  UInt_t fMiddleBufUsed;//(byte)
  //  Double_t fBuf1UsageRate;
  //  Double_t f1stTransCALDataBufUsage;
  //Double_t fMiddleBufUsageRate;
  //  Double_t fMedTransCALDataBufUsage;
  Int_t fWroteSize;
  UInt_t fWroteWord;
  Int_t fCurrentAddress;
  UInt_t fBufTimeSec;
  UInt_t fBufTimeFrac;
  UInt_t fCheckFullBuf1;
  UInt_t fMiddleTransLimitWord;
  UInt_t fRestWord;
  int fBuf1FullTimeSec;
  double fBuf1FullTimeFrac;
  UInt_t fCheckFullMiddleBuf;
  Int_t fBuf1FrontDataLength;
  UInt_t fRegularOutTimeSec;
  UInt_t fRegularOutTimeFrac;
  UInt_t fWriteForcibly1stFrame;
  UInt_t fWriteForciblyRestWord;

  UInt_t fSingleSelectionMode;
  UInt_t fGenEveData;
  UInt_t fGenRegData;
  //  UInt_t fTASCZeroSuppressed;
  UInt_t fSingleMaskHE;
  UInt_t fSingleMaskLE;
  UInt_t fSingleMaskSingle;
  UInt_t fSingleMaskHeavyHE;
  UInt_t fSingleMaskHeavyLE;
  UInt_t fSingleMaskHeavySingle;
  UInt_t Nhit_TASC;
  UInt_t NTHD_low;
  UInt_t NTHD_high;
  //  UInt_t A_IMC[N_XY];
  //  UInt_t A_TASC;
  static const unsigned int TEST_TASC= 1<<2 | 1<<1 | 0<<0;//high,low,single
  static const unsigned int TEST_IMCx= 1<<11 | 1<<10 | 1<<9 | 1<<8 | 1<<7 | 1<<6 | 1<<5 | 1<<4 | 0<<3 | 0<<2 | 0<<1 | 0<<0;//high1~4,low1~4,single1~4
  static const unsigned int TEST_IMCy= 1<<11 | 1<<10 | 1<<9 | 1<<8 | 1<<7 | 1<<6 | 1<<5 | 1<<4 | 0<<3 | 0<<2 | 0<<1 | 0<<0;
};
# 4 "/tmp/rootcint_hxzv6S.h" 2
# 1 "./include/LinkDef.h" 1

#pragma link off all globals;
#pragma link off all classes;
#pragma link off all functions;

#pragma link C++ class MDCSimulator+;
# 4 "/tmp/rootcint_hxzv6S.h" 2
# 2 "/tmp/18jMST_cint.cxx" 2
